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

No annotations are provided, so the description carries full burden. It mentions 'save/track a job,' which hints at a write operation, but lacks details on permissions, effects (e.g., duplicates, limits), or response behavior. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is two sentences, front-loaded with the main action and followed by usage context. It's efficient with minimal waste, though slightly repetitive in phrasing ('Add a job...' and 'save/track a job').

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 mutation tool with no annotations and no output schema, the description is incomplete. It lacks behavioral details (e.g., success/failure outcomes, constraints) and doesn't compensate for the missing structured data, making it insufficient for reliable agent use.

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

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

Schema description coverage is 100%, so the schema fully documents the two parameters (jobId and jobHuntId). The description adds no additional parameter details beyond what the schema provides, meeting the baseline of 3 for high coverage without extra 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 clearly states the action ('Add a job from search results to your applications') and resource ('job'), making the purpose understandable. However, it doesn't explicitly differentiate from siblings like 'apply_to_job' or 'import_job_by_url' beyond implying it's for saving/tracking rather than applying or importing.

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 some guidance with 'Use this when a user wants to save/track a job they found,' which implies a context of job search results. However, it doesn't specify when not to use it or mention alternatives like 'apply_to_job' for direct application, leaving usage somewhat 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 states the tool 'will automatically fill and submit,' implying a write operation, but does not disclose permissions needed, rate limits, or what happens on submission (e.g., confirmation, errors). This leaves significant gaps 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 front-loaded with the core purpose in the first sentence, followed by an optional detail. Both sentences are essential, with zero waste, making it highly efficient and well-structured.

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

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

Given no annotations and no output schema, the description is incomplete for a mutation tool. It covers the basic action but lacks details on behavioral traits, return values, or error handling. However, it is adequate for minimal understanding, aligning with a score of 3.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds minimal value by mentioning the optional resume parameter and referencing 'list_resumes' or 'upload_resume,' but does not provide additional semantics beyond what the schema states.

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

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

The description clearly states the specific action ('trigger auto-apply') and resource ('job application'), distinguishing it from siblings like 'get_application' (read) or 'update_application' (modify). It explicitly mentions 'automatically fill and submit the job application form,' which clarifies the automation aspect beyond just applying.

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 when auto-applying to a job, but does not explicitly state when to use this tool versus alternatives like 'send_outreach' or 'update_application'. It mentions an optional resume parameter, providing some context, but lacks guidance on prerequisites 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 full burden for behavioral disclosure. It mentions that a job hunt is needed for other operations, but doesn't describe what happens after creation (e.g., whether it's immediately active, how it's stored, if there are limits on concurrent hunts, or what the return value looks like). For a creation tool with zero annotation coverage, this leaves significant gaps in understanding the tool's 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 appropriately concise with two sentences. The first sentence states the purpose clearly, and the second provides important usage context. There's no wasted verbiage, and the information is front-loaded with the core functionality.

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 creation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after creation, what data is returned, whether there are side effects (like credit consumption mentioned in the schema's autoMode parameter), or how the created hunt integrates with the system. The schema handles parameter documentation well, but the description should provide more behavioral context.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond what's in the schema, only mentioning that a job hunt defines criteria 'based on titles, locations, skills, salary, etc.' This doesn't provide additional semantic context beyond the comprehensive 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 purpose: 'Create a new job hunt to start tracking and applying to jobs.' It specifies the verb ('create') and resource ('job hunt'), and explains that a job hunt defines search criteria. However, it doesn't explicitly distinguish this from sibling tools like 'update_job_hunt' or 'list_job_hunts' beyond mentioning that it's needed for 'match_jobs' and 'add_job_to_applications'.

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

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

The description provides clear context for when to use this tool: 'You need at least one job hunt to use match_jobs or add_job_to_applications.' This establishes a prerequisite relationship with other tools. However, it doesn't explicitly state when NOT to use it (e.g., vs. updating an existing hunt) or name specific alternatives among siblings.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key behavioral constraint (cannot delete primary resumes), which is crucial for a destructive operation. However, it lacks details on permissions, error handling, or confirmation steps, leaving gaps in behavioral understanding for a deletion 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 sentences, front-loaded with the core action and resource, followed by a critical constraint. Every word serves a purpose, with no redundancy or fluff, making it highly efficient and well-structured.

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

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

For a destructive tool with no annotations and no output schema, the description provides essential context (cannot delete primary resumes) but lacks details on outcomes (e.g., confirmation message, error responses) or broader implications. It's adequate given the simple parameter schema but could be more complete for a mutation operation.

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

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

Schema description coverage is 100%, with the parameter 'id' fully documented in the schema. The description does not add any additional semantic context beyond what the schema provides (e.g., format examples or source of the ID), so it meets the baseline for high schema coverage without extra 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 clearly states the action ('Delete') and resource ('an uploaded resume from your profile'), distinguishing it from sibling tools like 'upload_resume' or 'get_resume'. It specifies the scope of deletion (only alternate resumes, not primary), making the purpose explicit and 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 description explicitly states when not to use this tool ('You cannot delete your primary resume'), providing clear exclusion criteria. It implies usage for deleting alternate resumes, and while it doesn't name alternatives directly, the context from sibling tools (e.g., 'upload_resume', 'list_resumes') supports understanding of when to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool 'creates a customized version' and 'returns JSON resume data', but lacks critical details: whether this is a read-only or mutation operation, if it requires specific permissions or credits, what happens to existing resumes, or any rate limits. For a tool that likely involves AI processing and data generation, this is insufficient.

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

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

The description is concise and front-loaded, stating the core purpose in the first sentence. The second sentence elaborates on customization, and the third specifies the return format. There's minimal waste, though it could be slightly more structured (e.g., separating behavioral notes).

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

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

Given the complexity (AI generation, 5 parameters) and lack of annotations or output schema, the description is moderately complete. It covers the basic purpose and return format but misses key contextual details: prerequisites, behavioral traits (e.g., mutation effects, costs), and how it integrates with sibling tools. Without an output schema, it should ideally describe the JSON structure more.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond what's in the schema—it doesn't clarify parameter interactions, default behaviors beyond the schema's 'defaults' note, or examples of use. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('generate', 'creates', 'tailored', 'highlighting') and resources ('AI-optimized resume', 'specific job application'). It distinguishes itself from siblings like 'get_resume' or 'upload_resume' by focusing on generation and customization rather than retrieval or upload.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing resume or job application), nor does it differentiate from siblings like 'get_generated_resume' (which might retrieve previously generated resumes) or 'update_application' (which might modify job applications).

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 mentions the optional inclusion of job listing details, which adds some behavioral context. However, it lacks information on permissions needed, error handling (e.g., invalid ID), response format, or rate limits, which are important for a read operation 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 sentences with zero waste: the first sentence states the core purpose, and the second explains the optional parameter's effect. It is front-loaded and appropriately sized for the tool's complexity.

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

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

Given no annotations and no output schema, the description is minimally complete for a simple read tool. It covers the purpose and parameter effect, but lacks details on behavioral aspects like response structure or error conditions, which could be important for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters ('id' and 'includeJobListing'). The description adds marginal value by mentioning the optional inclusion of job listing details, but does not provide additional semantics beyond what the schema states. Baseline 3 is appropriate here.

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

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

The description clearly states the verb ('Get details') and resource ('specific job application by ID'), and distinguishes it from siblings like 'list_applications' (which lists multiple) or 'get_application_stats' (which provides aggregated data). It specifies the exact scope of retrieval.

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 when details of a single application are needed, but does not explicitly state when to use this tool versus alternatives like 'list_applications' for multiple applications or 'get_application_stats' for aggregated metrics. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It mentions the return type ('contact info for reaching out'), which adds some behavioral context, but fails to disclose critical traits like whether this is a read-only operation, requires authentication, has rate limits, or what happens if the application ID is invalid. For a tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the purpose and adds a brief note on return values. There is no wasted text, making it appropriately sized and easy to parse.

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

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

Given the tool's low complexity (one parameter, no output schema, no annotations), the description is minimally complete. It states the purpose and return type, but lacks details on usage context, behavioral traits, or error handling. Without annotations or output schema, it should do more to compensate, but it meets a basic threshold for a simple read 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?

The schema description coverage is 100%, with the parameter 'applicationId' documented as 'The job application ID'. The description does not add any meaning beyond this, such as format examples or sourcing details. With high schema coverage, the baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.

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

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

The description clearly states the action ('Get recruiters') and resource ('for a job application you have saved'), specifying it returns contact info. It distinguishes from some siblings like 'get_application' or 'get_job_recruiters' by focusing on recruiters tied to a saved application, but could be more explicit about differentiation from 'get_ob_recruiters'.

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

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

No guidance on when to use this tool versus alternatives like 'get_job_recruiters' or 'get_application_referrers' is provided. The description implies usage for saved applications but lacks explicit context or exclusions, leaving the agent to infer based on sibling tool names.

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

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

No annotations are provided, so the description carries full burden. It mentions the tool 'returns people at the company who might refer you,' which gives basic output context, but lacks details on behavioral traits like rate limits, authentication needs, data freshness, or error conditions. For a tool with no annotations, this is a significant gap in transparency.

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

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

The description is concise and front-loaded with the core purpose in the first sentence. Both sentences earn their place by stating the action and clarifying the return value. However, it could be slightly more structured by integrating usage hints.

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

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

Given no annotations and no output schema, the description is moderately complete. It covers the basic purpose and output type, but lacks details on behavioral context, error handling, or when to use versus siblings. For a tool with 2 parameters and 100% schema coverage, it's adequate but has clear gaps in guidance and transparency.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (applicationId and limit). The description doesn't add any meaning beyond what the schema provides, such as explaining what a 'potential referrer' entails or how the limit affects results. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Find potential referrers for a job application' specifies the action (find) and resource (referrers), and 'Returns people at the company who might refer you' elaborates on the output. It distinguishes from some siblings like 'get_application_recruiters' by focusing on referrers, but doesn't explicitly differentiate from 'get_job_referrers' which appears similar.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an application ID), compare to 'get_job_referrers' (a sibling tool), or specify contexts like post-application versus pre-application. Usage is implied by the name and parameters but not explicitly stated.

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

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

With no annotations provided, the description carries full burden. It mentions performance ('Much faster') which is useful behavioral context, but lacks details on permissions, rate limits, error conditions, or response format. It adequately indicates a read operation but could be more comprehensive.

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

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

Two sentences with zero waste: the first states purpose and scope, the second provides critical usage guidance. It's front-loaded with essential information and appropriately sized.

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 read-only stats tool with 2 parameters and no output schema, the description is mostly complete: purpose, scope, and performance comparison are covered. However, without annotations or output schema, it could better explain response structure or limitations.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description does not add any parameter-specific information beyond what's in the schema, but the baseline is 3 when schema coverage is high.

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 purpose with specific verbs ('Get aggregated stats') and resources ('job applications'), detailing what stats are provided ('total counts by status and auto-apply metrics'). It distinguishes from sibling 'list_applications' by emphasizing aggregation vs. pagination.

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?

Explicit guidance is provided on when to use this tool vs. alternatives: 'Much faster than paginating through list_applications' directly compares it to a sibling tool, indicating this is preferred for aggregated stats over detailed listings.

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 mentions retrieving credit balance and usage, which implies a read-only operation, but doesn't specify authentication needs, rate limits, error conditions, or what the return format looks like (e.g., structured data, currency units). This leaves significant gaps for an agent to understand how to handle the tool effectively.

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 that directly states the tool's purpose without any fluff or redundant information. It's front-loaded and appropriately sized for a simple tool with no 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?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks depth. It covers the basic purpose but omits details on behavior, output format, and usage context, which could hinder an agent's ability to integrate it smoothly into workflows. The absence of an output schema means the description should ideally hint at return values, but it doesn't.

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 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description appropriately doesn't discuss parameters, which is efficient. A baseline of 4 is applied since no parameters exist, and the description doesn't need to compensate for any 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 tool's purpose with a specific verb ('Get') and resource ('your current credit balance and usage information'), making it immediately understandable. However, it doesn't distinguish this tool from any potential siblings that might also retrieve credit-related data, though none are listed among the provided sibling tools.

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

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

The description provides no guidance on when to use this tool versus alternatives, prerequisites, or contextual constraints. It merely states what the tool does without indicating scenarios where it's appropriate or how it relates to other tools in the set.

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 implies this is a read-only operation ('Get the list'), but doesn't explicitly state whether it requires authentication, has rate limits, or describes the return format. The description adds some context about the tool's purpose but lacks comprehensive 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 perfectly concise with two sentences that each serve distinct purposes: the first defines what the tool does, the second provides usage guidance. There's zero wasted language, and the most important information (the tool's purpose) comes first.

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

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

For a simple read operation with no parameters and no output schema, the description provides adequate context about what data is returned (codes, symbols, units) and when to use it. However, without annotations or output schema, it could benefit from more detail about the return format or any limitations.

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 0 parameters with 100% schema description coverage, so the schema fully documents the absence of parameters. The description appropriately doesn't discuss parameters, maintaining focus on the tool's purpose and usage. This meets the baseline expectation for parameterless tools.

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

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

The description clearly states the verb 'Get' and the resource 'list of supported currencies', specifying what information is included (codes, symbols, and units). It distinguishes this tool from siblings like get_salary or get_profile by focusing specifically on currency 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?

The description provides explicit guidance on when to use this tool ('to look up the correct currency code before updating salary'), which connects it to the update_salary sibling. However, it doesn't explicitly state when NOT to use it or mention alternatives for currency-related operations.

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

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

No annotations are provided, so the description carries full burden. It states it retrieves details and a download URL, implying a read-only operation, but doesn't disclose behavioral traits like authentication requirements, rate limits, error conditions (e.g., invalid ID), or response format. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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

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

The description is a single, efficient sentence with zero waste. It front-loads the core purpose ('Get details') and includes a key detail ('download URL') without unnecessary elaboration. Every word earns its place, making it highly concise and well-structured.

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

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

Given no annotations and no output schema, the description is incomplete for a tool that likely returns structured data. It mentions 'details' and a 'download URL' but doesn't explain what other details are included, the response format, or potential errors. For a read operation with one parameter, it should provide more context about the output and usage scenarios.

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

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

Schema description coverage is 100%, with the parameter 'id' clearly documented as 'The generated resume ID'. The description adds no additional meaning beyond this, such as format examples or where to obtain the ID. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb 'Get' and resource 'details of a specific AI-generated resume including the download URL', making the purpose evident. It distinguishes from siblings like 'get_resume' (likely for user-uploaded resumes) and 'list_generated_resumes' (listing multiple). However, it doesn't explicitly contrast with these siblings in the description text itself.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a generated resume ID from 'generate_resume_for_job'), when not to use it, or how it differs from 'get_resume' or 'list_generated_resumes'. The agent must infer usage from the name and context alone.

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

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

No annotations are provided, so the description carries the full burden. It implies this is a read-only operation ('Get the list') and specifies the data's purpose as reference values for filters. However, it doesn't mention potential limitations like rate limits, authentication needs, or data freshness.

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

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

The description is two concise sentences with zero waste. The first sentence states the purpose, and the second provides explicit usage guidance. Every word earns its place.

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

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

For a simple read-only tool with no parameters and no output schema, the description is mostly complete. It explains what the tool does and how to use the output. However, without annotations or output schema, it could benefit from mentioning the return format (e.g., list of strings) or any constraints.

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 0 parameters, and schema description coverage is 100%. The description doesn't need to explain parameters, but it adds value by clarifying the output's semantic purpose as filter values for other tools, which goes beyond what the empty schema 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 clearly states the tool's purpose with a specific verb ('Get') and resource ('list of valid company industries'). It distinguishes itself from siblings by focusing on retrieving reference data rather than job applications, resumes, or job hunts.

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 explicitly states when to use this tool: 'Use these values for the "industries" filter in search_jobs, create_job_hunt, or update_job_hunt.' It provides clear alternatives by naming three specific sibling tools where the output should be applied.

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

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

No annotations are provided, so the description carries full burden. It implies a read-only operation ('get', 'view') but doesn't explicitly state permissions, rate limits, or error behavior. It does add useful context about what information is returned (description, salary, skills, company info), which goes beyond basic purpose.

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

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

Two sentences with zero waste. First sentence states purpose and key constraint. Second sentence provides usage guidance and alternative. Every word earns its place, and the most critical 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?

For a simple read operation with 1 parameter and no output schema, the description is reasonably complete. It covers purpose, key constraint (ID type), usage guidance, and return content. However, without annotations or output schema, it could benefit from more behavioral details like error cases or response format.

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

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

Schema description coverage is 100%, so the schema already documents the 'id' parameter. The description adds marginal value by clarifying it's a 'job listing ID (not application ID)', which helps disambiguate from similar identifiers, but doesn't provide format examples or constraints beyond what the schema implies.

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

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

The description clearly states the verb 'get' and resource 'detailed information about a specific job listing/posting', specifying it's by 'job listing ID (not application ID)'. It distinguishes from sibling get_application by explicitly contrasting job posting details vs. application details.

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

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

Explicitly states when to use this tool ('to view the full job posting details') and when not to ('not application ID'), and provides a clear alternative ('use get_application instead'). This directly addresses sibling tool differentiation.

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 states it 'gets details' but doesn't clarify if this is a read-only operation, what details are returned, error handling, or any rate limits. This is inadequate for a tool with zero annotation coverage.

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 with no wasted words, clearly front-loading the core functionality. It's appropriately sized for a simple lookup tool.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what details are returned, potential errors, or behavioral traits, making it insufficient for an agent to fully understand the tool's operation beyond basic purpose.

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

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

The description adds minimal meaning beyond the input schema, which has 100% coverage and fully documents the 'id' parameter. It implies the parameter is used to identify a specific job hunt, but doesn't provide additional context like format examples or constraints, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('Get details') and resource ('a specific job hunt by ID'), making the purpose evident. However, it doesn't differentiate from sibling tools like 'get_job' or 'list_job_hunts', which would require specifying it retrieves a single job hunt entity by its identifier.

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. For example, it doesn't mention using 'list_job_hunts' for multiple job hunts or 'get_job' for job details instead, leaving the agent to infer usage from the name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the return content but does not specify whether this is a read-only operation, if it requires authentication, any rate limits, or error conditions. The description adds minimal context beyond the basic function.

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

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

The description is a single, efficient sentence that front-loads the purpose and key details. Every word contributes to understanding the tool's function without redundancy or unnecessary elaboration.

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

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

Given the tool's low complexity (one parameter, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose and return values, but lacks details on usage context, behavioral traits, or error handling that would be helpful 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?

The input schema has 100% description coverage, with the 'jobId' parameter clearly documented. The description does not add any additional meaning or examples beyond what the schema provides, such as format or sourcing of the job ID, so it meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Get recruiters') and resource ('associated with a specific job'), and specifies the return content ('contact info including email and LinkedIn'). It distinguishes from some siblings like 'get_job' or 'get_application_recruiters' by focusing on job-specific recruiters, though not explicitly contrasting with all similar tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_application_recruiters' or 'get_job_referrers'. It lacks context about prerequisites, such as needing a valid job ID from another operation, or exclusions for when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that it 'Returns people who might be able to refer you based on your network and the job,' which gives some context about the matching logic. However, it doesn't cover important aspects like whether this is a read-only operation, potential rate limits, authentication needs, or what happens if no referrers are found. For a tool with zero annotation coverage, 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 appropriately sized with two clear sentences that efficiently convey the tool's purpose and return behavior. It's front-loaded with the main action and avoids unnecessary details. However, it could be slightly more structured by explicitly separating purpose from behavioral context, keeping it from a perfect score of 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's moderate complexity (finding referrers based on network matching), lack of annotations, and no output schema, the description is minimally adequate. It explains what the tool does and the basic matching logic, but doesn't cover behavioral traits, error conditions, or output format. With no annotations or output schema, a more complete description would help the agent understand the tool's full context, resulting in a score of 3.

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 both parameters ('jobId' and 'limit') well-documented in the schema. The description doesn't add any additional semantic information about the parameters beyond what's in the schema (e.g., it doesn't explain what a 'jobId' refers to or provide context for the limit). According to the rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the tool's purpose: 'Find potential referrers at a company for a specific job.' It specifies both the action (find) and the resource (referrers for a job), and distinguishes it from sibling tools like 'get_application_referrers' by focusing on jobs rather than applications. However, it doesn't explicitly differentiate from 'get_job_recruiters' or other job-related tools, keeping it at a 4 rather than a 5.

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

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

The description implies usage context ('based on your network and the job') but doesn't explicitly state when to use this tool versus alternatives like 'get_application_referrers' or 'get_job_recruiters'. It provides some guidance by mentioning the network-based matching, but lacks clear exclusions or named alternatives, resulting in a score of 3 for implied usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only operation ('Get') but doesn't specify authentication requirements, rate limits, error conditions, or what happens if no profile exists. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose and lists included data types without unnecessary details. Every word earns its place, making it easy to parse quickly.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but minimal. It explains what data is retrieved but lacks details on format, authentication, or error handling. For a read-only tool with no structured support, this is the minimum viable—clear gaps exist in behavioral context.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the data returned. This meets the baseline for tools with no parameters.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('your user profile'), and lists the types of information included (personal info, skills, experience, work history). However, it doesn't explicitly distinguish this tool from sibling tools like 'get_resume' or 'update_profile', which might retrieve or modify similar 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for usage, or compare it to siblings like 'get_resume' or 'update_profile', leaving the agent to infer usage scenarios based on the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves details including a download URL, but lacks information on permissions required, rate limits, error handling, or response format. This is a significant gap for a read operation with no annotation coverage.

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 with zero waste. It front-loads the core purpose ('Get details of a specific uploaded resume') and includes a key detail ('including download URL'), making it appropriately sized and structured.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with behavioral and output uncertainties. It covers the basic purpose but lacks details on permissions, response structure, or error cases. However, the schema fully documents inputs, and the purpose is straightforward, making it minimally adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters ('id' and 'includeRawTxt'). The description adds no additional parameter semantics beyond implying the 'id' is for a specific resume, which is already clear from the schema. Baseline 3 is appropriate as the schema handles 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 verb ('Get') and resource ('details of a specific uploaded resume'), making the purpose evident. However, it does not explicitly differentiate from sibling tools like 'list_resumes' or 'get_generated_resume', which would require mentioning it retrieves a single resume by ID rather than listing or fetching generated versions.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a resume ID from 'list_resumes'), exclusions, or comparisons to siblings like 'get_generated_resume' or 'list_resumes', leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries full burden. It indicates a read operation ('Get') but lacks details on permissions required, data freshness, rate limits, or error conditions. For a tool accessing sensitive compensation data with zero annotation coverage, this is a significant gap in 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 a single, efficient sentence that front-loads the core purpose and details the specific compensation components. Every word adds value with zero waste, making it highly concise and well-structured.

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

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

Given the tool's simplicity (0 parameters, no output schema) and lack of annotations, the description adequately covers the purpose. However, it does not address behavioral aspects like authentication needs or return format, which are important for a tool handling sensitive data, leaving some contextual 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 tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics without redundant parameter info, earning a baseline score above minimum viable.

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 specific action ('Get') and resource ('your current salary/compensation details'), including the exact data fields returned (base, stocks, bonus, total compensation). It distinguishes itself from sibling tools like 'update_salary' by focusing on retrieval rather than modification.

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 personal compensation data, but does not explicitly state when to use this tool versus alternatives (e.g., 'get_profile' might include salary, or 'update_salary' for modifications). No exclusions or prerequisites are mentioned, leaving usage context somewhat vague.

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 mentions the tool imports a job and optionally triggers auto-apply, but lacks details on permissions needed, rate limits, error handling, or what happens during import (e.g., data parsing, validation). This is insufficient for a mutation tool with zero annotation coverage.

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 front-loaded and efficiently structured in two sentences with zero waste. The first sentence states the core action and optional feature, and the second provides clear usage context, making it easy to understand quickly.

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

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

Given the tool's complexity (mutation with 3 parameters) and lack of annotations and output schema, the description is moderately complete. It covers the purpose and basic usage but lacks behavioral details like side effects, return values, or error conditions, which are important for a tool that modifies data and interacts with external URLs.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by implying the URL supports specific platforms and mentioning the auto-apply option, but does not provide additional syntax or format details beyond what the schema provides, meeting the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose with specific verbs ('import', 'add') and resources ('job from a URL', 'to your applications'), and distinguishes it from siblings by specifying it handles direct job posting URLs from platforms like LinkedIn, Greenhouse, etc., unlike generic job-related tools such as 'add_job_to_applications' or 'search_jobs'.

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

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

The description provides explicit context for when to use this tool ('when a user has a direct link to a job posting'), which helps differentiate it from alternatives. However, it does not explicitly state when not to use it or name specific sibling tools as alternatives, such as 'add_job_to_applications' for manual job entry.

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 but reveals little behavioral information. It doesn't disclose whether this is a read-only operation, what permissions are needed, whether results are paginated (though schema hints at this), rate limits, or what the return format looks like. The description adds minimal value beyond the basic operation.

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

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

The description is a single, efficient sentence that communicates the core purpose and key filtering options. There's no wasted language or unnecessary elaboration - every word serves a purpose in this compact statement.

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 operation with 4 well-documented parameters but no annotations or output schema, the description is minimally adequate. It states what the tool does but lacks important context about behavior, return format, and differentiation from similar tools. The absence of output schema means the description should ideally provide more guidance about what to expect.

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

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

Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description mentions filtering by 'job hunt or status' which aligns with two parameters, but adds no additional semantic context beyond what the schema provides. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb 'List' and resource 'job applications' with optional filtering capability. It distinguishes from siblings like 'get_application' (singular) and 'update_application' (mutation), but doesn't explicitly differentiate from other list tools like 'list_job_hunts' or 'list_resumes' beyond the resource type.

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 minimal guidance - it mentions optional filtering by job hunt or status, but offers no context about when to use this tool versus alternatives like 'search_jobs' or 'match_jobs'. No prerequisites, exclusions, or comparison to sibling list operations 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 behavioral disclosure. It states the tool lists resumes but doesn't describe output format, pagination, sorting, permissions required, rate limits, or whether it's a read-only operation. The phrase 'automatically tailored' hints at generation context but lacks 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?

The description is two concise sentences with zero waste, front-loading the core action ('List AI-generated custom resumes'). It could be slightly improved by integrating filtering hints, but it's efficiently structured and appropriately sized for the tool's complexity.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what the output contains (e.g., resume metadata, content, links), how results are organized, or error conditions. For a list operation with filtering parameters, more context on behavior and results is needed to be fully helpful.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (jobApplicationId, manualTrigger). The description adds no parameter-specific information beyond what's in the schema, such as example values or combined filtering logic. Baseline 3 is appropriate when the schema handles 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 tool's purpose: 'List AI-generated custom resumes' with the specific resource (resumes) and qualification (AI-generated, tailored for job applications). It distinguishes from siblings like 'list_resumes' by specifying the AI-generated subset, though it doesn't explicitly contrast with 'get_generated_resume' (singular) or 'list_applications'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_resumes' (which might include all resumes) or 'get_generated_resume' (which retrieves a single resume), nor does it specify prerequisites or contextual triggers for listing generated resumes.

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 mentions that interviews are 'detected from email confirmations,' which adds context about data sourcing, but it doesn't cover critical behavioral aspects such as pagination behavior (implied by 'page' and 'limit' parameters but not explained), rate limits, authentication requirements, or whether this is a read-only operation. For a list tool with 5 parameters, this leaves significant gaps in understanding how the tool behaves in practice.

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

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

The description is concise and front-loaded: the first sentence states the core purpose, and the second sentence provides key usage tips. There's no wasted text, and it efficiently covers essential points in two sentences. However, it could be slightly more structured by explicitly separating purpose from filtering options for better 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 complexity (5 parameters, no output schema, no annotations), the description is incomplete. It lacks details on behavioral traits (e.g., pagination, rate limits), does not explain return values or error handling, and provides minimal guidance on tool selection versus siblings. For a list tool with filtering and pagination, this leaves the agent with insufficient context to use it effectively beyond basic parameter passing.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema: it mentions 'upcoming=true' to get scheduled/rescheduled interviews and filtering by application ID or status, but these are already clear from the schema's enum and descriptions. No additional syntax, format, or usage details are provided, so it meets the baseline for high schema coverage without enhancing parameter understanding.

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

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

The description clearly states the tool's purpose: 'List job interviews that are being actively tracked by JobGPT (detected from email confirmations).' It specifies the verb ('List') and resource ('job interviews'), and mentions the source of data ('detected from email confirmations'), which adds useful context. However, it doesn't explicitly differentiate from sibling tools like 'list_applications' or 'get_application', which might also relate to interviews indirectly.

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 some implied usage guidance: it mentions using 'upcoming=true' to get scheduled/rescheduled interviews and filtering by application ID or status. However, it doesn't explicitly state when to use this tool versus alternatives (e.g., 'list_applications' for broader application data) or any prerequisites. The guidance is functional but lacks comparative context with sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the tool 'Also returns your current credits balance,' which adds useful context beyond a simple list operation. However, it lacks critical details: it doesn't specify if this is a read-only operation, whether it requires authentication, how pagination works (beyond what's in the schema), or what the output format looks like. For a tool with no annotations, this leaves significant gaps in understanding its 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 concise and front-loaded, stating the primary purpose in the first clause. The second clause adds useful context about the credits balance. Both sentences earn their place by providing distinct information. However, it could be slightly more structured by explicitly separating the list operation from the credits return.

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

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

Given the tool's low complexity (2 optional parameters, no output schema, no annotations), the description is moderately complete. It covers the main action and an additional return value (credits balance), but lacks details on authentication, error handling, or output structure. Without annotations or an output schema, the agent must infer these aspects, making the description adequate but with clear gaps for a read 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?

The schema description coverage is 100%, with both parameters ('page' and 'limit') fully documented in the input schema. The description adds no additional parameter information beyond what the schema provides. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even with no param info in the description, which applies here.

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

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

The description clearly states the tool's purpose: 'List your saved job hunts (job searches).' It specifies the verb ('list') and resource ('saved job hunts'), distinguishing it from siblings like 'get_job_hunt' (singular) or 'create_job_hunt'. However, it doesn't explicitly differentiate from other list tools like 'list_applications' or 'list_resumes' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use it over 'get_job_hunt' for a single hunt, or how it relates to other list tools like 'list_applications'. There's also no indication of prerequisites or context for usage, such as authentication needs or data availability.

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

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

No annotations are provided, so the description carries full burden. It states the tool lists emails, implying a read-only operation, but doesn't disclose behavioral traits like pagination behavior (implied by parameters but not described), authentication needs, rate limits, or what happens if no outreaches exist. The description is minimal and lacks operational context.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with zero waste. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given no annotations, no output schema, and a list operation with pagination parameters, the description is incomplete. It doesn't cover return values (e.g., format of listed emails), error conditions, or usage context, leaving gaps for an agent to understand how to interpret results or handle edge cases.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no meaning beyond the schema—it doesn't explain how parameters interact (e.g., filtering by jobApplicationId with pagination) or provide examples. Baseline score of 3 applies as the schema does the heavy lifting.

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

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

The description clearly states the action ('List') and resource ('outreach emails'), specifying they are 'sent to recruiters and referrers.' It distinguishes from siblings like 'send_outreach' (which creates) and 'get_application_recruiters' (which focuses on recruiters for an application), but doesn't explicitly differentiate from other list tools like 'list_applications' or 'list_interviews' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing existing outreaches), exclusions, or comparisons to siblings like 'get_application_recruiters' or 'get_application_referrers' that might retrieve related data. Usage is implied by the resource name alone.

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

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

No annotations are provided, so the description carries full burden. It discloses that it returns all resumes (implying no filtering) and includes primary and alternate versions, but lacks details on permissions, rate limits, pagination, or error behavior. The description is accurate but minimal for a read operation.

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

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

Two concise sentences front-load the core action and scope, with no wasted words. The first sentence states the purpose, and the second elaborates on what's included, earning its place by clarifying the return content.

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

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

Given the tool's low complexity (1 optional parameter, no output schema, no annotations), the description is reasonably complete for a list operation. It covers what is returned but lacks details on format, ordering, or limitations. For a simple tool, this is adequate but not exhaustive.

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 1 parameter with 100% coverage, so the baseline is 3. The description does not mention the parameter 'includeRawTxt', but since there are 0 required parameters and the schema fully describes it, this is acceptable. No additional parameter semantics are provided, but the tool's purpose is clear without them.

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

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

The description clearly states the verb 'List' and the resource 'your uploaded resumes', specifying scope with 'all resumes you have uploaded to your profile, including your primary resume and any alternate versions'. It distinguishes from sibling tools like 'get_resume' (singular) and 'upload_resume' (upload action).

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 all uploaded resumes, but does not explicitly state when to use this tool versus alternatives like 'get_resume' (for a specific resume) or 'list_generated_resumes' (for AI-generated ones). No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries full burden. It discloses key behavioral traits: it filters out jobs already seen, applied to, or rejected, and relies on saved configurations. However, it lacks details on rate limits, authentication needs, error conditions, or response format, leaving gaps for a tool with mutation-like implications (tracking seen jobs).

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

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

Two sentences, front-loaded with core purpose. Every phrase adds value: first sentence defines action and constraints, second provides clear alternative. No wasted words, efficiently 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 tool with no annotations and no output schema, the description is moderately complete. It covers purpose, usage, and some behavior (filtering), but lacks details on return values, error handling, or side effects (e.g., marking jobs as seen). Given the complexity and missing structured data, it should do more to compensate.

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

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

Schema description coverage is 100%, so the schema fully documents parameters (jobHuntId, limit, page). The description adds no additional parameter semantics beyond implying jobHuntId ties to saved filters. Baseline 3 is appropriate as the schema handles heavy lifting.

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

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

The description clearly states the specific action ('Get new job matches') and resource ('based on a saved job hunt configuration'), distinguishing it from siblings like 'search_jobs' (general search) and 'get_job_hunt' (retrieves configuration). It specifies the scope: uses saved filters and excludes already seen/applied/rejected jobs.

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

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

Explicitly states when to use this tool ('to get new job matches based on saved filters') and when to use an alternative ('To change filters, use update_job_hunt first'). It also implies usage context by mentioning it only returns unseen jobs, guiding the agent on appropriate scenarios.

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 mentions that the tool 'returns a list of matching job postings', which implies a read-only operation, but doesn't clarify if it's safe, whether it requires authentication, or if there are rate limits. For a search tool with 16 parameters and no annotations, this is insufficient to guide an agent on behavioral traits like performance or access requirements.

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

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

The description is a single, efficient sentence that front-loads the core functionality (search with filters) and the output (list of job postings). It avoids unnecessary words, though it could be slightly more structured by explicitly mentioning key constraints or alternatives.

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

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

Given the complexity (16 parameters, no output schema, no annotations), the description is minimally adequate. It covers what the tool does and the output type, but lacks details on behavioral aspects like authentication, rate limits, error handling, or pagination behavior. Without annotations or output schema, the description should do more to compensate, but it only partially meets the needs for such a parameter-rich tool.

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

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

The description lists example filter types (titles, locations, companies, skills, salary, remote options), which adds some context beyond the schema. However, with 100% schema description coverage, the schema already documents all 16 parameters thoroughly. The description doesn't provide additional syntax, format details, or usage tips that aren't already in the schema descriptions, so it meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Search for jobs with filters... Returns a list of matching job postings.' It specifies the verb (search), resource (jobs), and output (list of job postings). However, it doesn't explicitly differentiate from sibling tools like 'match_jobs' or 'get_job', which could have overlapping functionality.

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 'match_jobs' or 'get_job'. It mentions filters but doesn't specify prerequisites, such as whether authentication is required or if there are rate limits. 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool sends an email, implying a write/mutation operation, but does not disclose critical traits like whether it's idempotent, requires specific permissions, has rate limits, or what happens on failure. The mention of 'configured email' adds some context but is insufficient 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 concise with two sentences that directly address the tool's function and email source. It is front-loaded with the core purpose, and there is no redundant information. However, it could be slightly more structured by explicitly separating purpose from behavioral details.

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 mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., side effects, error handling), prerequisites (e.g., how to obtain contact IDs), and expected outcomes. The context signals indicate full schema coverage, but the description does not compensate for the missing behavioral and output information.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description does not add any parameter-specific semantics beyond what the schema provides (e.g., it doesn't explain format constraints or relationships between parameters like 'applicationId' and 'contactId'). Baseline 3 is appropriate as the schema handles 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 tool's purpose: 'Send an outreach email to a recruiter or referrer for a job application.' It specifies the verb ('send'), resource ('outreach email'), and target ('recruiter or referrer'), but does not explicitly differentiate it from sibling tools like 'list_outreaches' or 'update_application'.

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 minimal guidance: it mentions sending 'for a job application' and that the email is sent 'from your configured email.' However, it lacks explicit when-to-use criteria, does not mention prerequisites (e.g., needing contact IDs from 'get_application_recruiters' or 'get_application_referrers'), and offers no alternatives or exclusions compared to siblings.

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

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

No annotations are provided, so the description carries full burden. It states this is an update operation, implying mutation, but doesn't disclose behavioral traits like required permissions, whether changes are reversible, error handling (e.g., invalid status), or side effects. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action ('Update a job application') and specifies the updatable fields directly. Every part earns its place, making it easy to scan and understand quickly.

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 this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., permissions, side effects), usage context, or return values. While the schema covers parameters well, the overall context for safe and effective use is lacking, especially compared to siblings with similar 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 100%, so the schema already documents all parameters (id, status, notes) with descriptions and examples. The description adds minimal value beyond the schema by mentioning 'status or notes', but doesn't provide additional context like format constraints or interdependencies. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb ('Update') and resource ('a job application'), specifying what fields can be updated ('status or notes'). It distinguishes from siblings like 'get_application' (read-only) and 'list_applications' (listing), but doesn't explicitly differentiate from 'update_job_hunt' or 'update_profile' which update different resources.

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. It doesn't mention prerequisites (e.g., needing an existing application ID), exclusions (e.g., cannot update certain fields), or compare with siblings like 'update_job_hunt' for different contexts. The description only states what it does, not when to choose it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively explains the critical behavioral trait that 'config replaces the existing config (not a partial merge)', which is essential for correct usage. However, it doesn't mention authentication requirements, rate limits, or error conditions that might be relevant 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 efficiently structured with three sentences that each serve a distinct purpose: stating the tool's purpose, explaining the replacement behavior, and providing procedural guidance. There's no wasted language, and the most critical information ('IMPORTANT' about replacement behavior) is appropriately emphasized.

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 mutation tool with 8 parameters, nested objects, and no annotations or output schema, the description provides good contextual completeness. It explains the critical replacement behavior and procedural requirements. However, it doesn't describe what happens on success/failure or return values, which would be helpful given the absence of an output 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 100%, so the schema already documents all parameters thoroughly. The description adds minimal parameter-specific information beyond what's in the schema, mainly emphasizing the replacement behavior of the config parameter. This meets the baseline expectation when schema coverage is complete.

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 purpose with specific verbs ('update job hunt settings and search filters') and resources ('job hunt'), and distinguishes it from sibling tools by explicitly mentioning get_job_hunt as a prerequisite. It goes beyond just restating the name to explain what the tool actually does.

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

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

The description provides explicit guidance on when to use this tool ('to change what jobs are matched') and includes crucial procedural instructions: 'Use get_job_hunt first to see current config, then include all fields you want to keep.' It also warns about the replacement behavior versus partial merge, which is essential usage guidance.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Update' implies a mutation operation, but the description doesn't mention whether this requires authentication, what happens to unspecified fields (partial updates vs. overwrites), whether changes are reversible, or any rate limits/constraints. For a mutation tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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 - a single five-word phrase. While efficient, it may be too brief given the tool's complexity (5 parameters, mutation operation). Every word earns its place, but more context could be helpful. The structure is front-loaded with the core action, though it lacks any elaboration.

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 mutation tool with 5 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't address authentication requirements, error conditions, response format, or the implications of updating profile fields in the broader context of job applications and resumes. The agent would need to guess about many operational aspects.

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 all parameters are documented in the schema itself. The description adds no additional parameter information beyond what's in the schema - it doesn't explain relationships between parameters, provide examples of combined usage, or clarify which fields are most important. With complete schema coverage, the 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 'Update your user profile fields' clearly states the action (update) and target (user profile fields), but it's somewhat vague about scope. It doesn't specify which fields can be updated or differentiate from sibling tools like 'get_profile' beyond the obvious action difference. The purpose is understandable but lacks specificity.

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. While 'get_profile' is clearly a read operation and this is an update, there's no mention of prerequisites, permissions needed, or contextual cues for when profile updates are appropriate versus other profile-related operations. The description assumes the agent knows when profile updates are needed.

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 states 'Update' implying a mutation, but doesn't mention permissions needed, whether changes are reversible, or what happens to existing salary data not included in the update. This is inadequate for a mutation tool with zero annotation coverage.

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 with no wasted words, making it easy to parse and front-loaded with the core action. Every word earns its place, achieving optimal conciseness.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the update affects (e.g., user profile, job application), success conditions, or return values, leaving significant gaps for an agent to use it correctly.

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

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

The input schema has 100% description coverage, providing clear details for all 6 parameters (e.g., 'currency' with code examples). The description adds no additional parameter semantics beyond the schema, so it meets the baseline of 3 without compensating or detracting.

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 ('your salary/compensation details'), making the tool's purpose understandable. However, it doesn't differentiate from sibling tools like 'update_profile' or 'get_salary' that might handle related data, so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_profile' (which might include salary) or 'get_salary' (for reading). It lacks context on prerequisites, such as whether a user profile must exist first, leaving usage ambiguous.

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 and does well by disclosing key behavioral traits: file format constraints (PDF, DOC, DOCX), size limits (5MB), default behavior (profile syncing), and the effect of the isAltResume parameter. It doesn't mention authentication requirements, rate limits, or error conditions, but covers the essential operational constraints.

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

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

The description is efficiently structured with four sentences that each serve a distinct purpose: stating the core function, listing constraints, providing implementation guidance, and explaining parameter behavior. There's no wasted text, and key 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?

For a mutation tool with no annotations and no output schema, the description provides good coverage of operational constraints and parameter behavior. It could be more complete by mentioning authentication requirements, response format, or error handling, but given the schema's thorough parameter documentation, it's reasonably complete for the agent's needs.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it mentions the purpose of 'isAltResume' and that 'syncProfile' is ignored for alt resumes, but doesn't provide additional context about parameter interactions or usage patterns.

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 specific action ('Upload a resume as base64 file content') and distinguishes it from sibling tools like 'delete_resume' or 'get_resume' by focusing on file upload functionality. It specifies the resource (resume) and the method (base64 encoding).

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

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

The description provides clear context for when to use this tool (uploading resumes with specific formats and size limits) and mentions the 'isAltResume' parameter for alternative use cases. However, it doesn't explicitly state when NOT to use it or name specific alternatives among sibling tools like 'generate_resume_for_job' or 'import_job_by_url'.

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