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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It identifies the operation as saving/tracking but does not disclose side effects, idempotency, preconditions (e.g., job must exist, job hunt must exist), or error behavior. This is minimal 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 two sentences long, front-loaded with the action, and contains no redundant or filler content. Every word earns its place.

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

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

For a tool with two required parameters and no output schema, the description plus schema provide sufficient context for most use cases. The main gap is the lack of details on side effects and preconditions, but given the tool's simplicity, the description is reasonably complete.

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

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

The input schema provides full descriptions for both jobId and jobHuntId (100% schema coverage), so the baseline is 3. The description adds no extra parameter-specific meaning beyond what the schema already says.

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.' It uses a specific verb and resource, and the context distinguishes it from siblings like apply_to_job (which implies actually applying) and list_applications (which lists existing 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 explicitly says 'Use this when a user wants to save/track a job they found,' providing a clear when-to-use scenario. It does not mention alternatives or when not to use it, but the usage context is unambiguous.

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

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

With no annotations, the description must carry the transparency burden. It discloses the core mutating behavior (filling and submitting the form) and the optional resume selection. However, it omits potential side effects such as credit consumption, irreversibility, or prerequisites like requiring an active job hunt.

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

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

The description is two sentences, front-loaded with the primary action, and contains no redundant or filler information. Every word contributes to understanding the 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?

This is a simple action tool with two parameters, one required, and no output schema. The description adequately covers the action and the optional resume parameter, thanks to strong schema descriptions. It could be improved by noting required conditions or side effects, but it is sufficient for basic usage.

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

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

Schema coverage is 100%, and both parameters are well-described in the input schema. The tool description adds minimal extra meaning beyond the schema, only rephrasing the resume option without new details.

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

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

The description clearly states a specific action ('Trigger auto-apply') on a specific resource ('job application') and explains the mechanism (automatically fill and submit). This distinctly separates it from sibling tools like update_application or 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?

It provides clear context that this tool is for automating a job application submission. However, it does not explicitly name alternative tools or state when not to use it, leaving room for the agent to infer based on the action.

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 burden. It discloses that deletion is limited to alternate resumes, which is valuable behavioral context. However, it does not discuss the permanence of deletion, potential side effects, or any required permissions beyond the basic action.

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

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

The description is two sentences, front-loaded with the action and followed by a necessary constraint. Every word earns its place; there is no fluff or redundant explanation.

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

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

For a simple one-parameter delete tool with no output schema, the description is largely complete. It conveys the purpose and the key restriction. It could have mentioned how to obtain the resume ID (e.g., via list_resumes) or what happens after a successful deletion, but those are not strictly necessary.

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

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

The input schema has 100% description coverage for the 'id' parameter ('The resume ID (URI) to delete'). The description does not add extra meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the action 'Delete an uploaded resume from your profile' with a specific verb and resource. It distinguishes itself from sibling tools like list_resumes, get_resume, and upload_resume_* by focusing on deletion, and adds a key constraint about primary resumes.

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 implicitly tells when to use (to delete an uploaded resume) and explicitly gives a when-not scenario: 'You cannot delete your primary resume, only alternate resumes.' It does not name alternative tools, but the primary/alternate distinction is a clear usage boundary.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does state that it returns JSON resume data and uses AI optimization, but it does not mention any side effects, such as whether the generated resume is saved for later retrieval or if credits are consumed. This leaves some ambiguity for an agent.

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 purpose and a brief elaboration of behavior and output. Every word is useful, and there is no redundancy or fluff.

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

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

The description adequately explains the tool's action and return type, but it does not cover the lifecycle of the generated resume. Given the sibling tools for managing generated resumes, it would be helpful to mention whether the output is persisted and can be retrieved later, which is a notable gap.

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

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

The input schema provides 100% coverage for all five parameters, so the baseline is 3. The description does not add any extra meaning or context about the parameters beyond what the schema already documents.

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 (generate), the resource (resume), and the specific context (tailored for a job application). This distinguishes it from sibling resume tools like get_resume or upload_resume_from_file by emphasizing generation and job-specific customization.

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

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

The description gives clear context for when to use the tool: when an AI-optimized resume tailored to a specific job application is needed. It does not explicitly exclude alternatives, but the purpose is unambiguous enough for an agent to select it appropriately.

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

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

No annotations are provided, so the description carries the burden. It discloses the optional inclusion of job listing details, which is a behavioral aspect, but omits response shape, error behavior, and permission requirements. For a simple read operation, this is adequate but not rich.

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

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

Single sentence with a clear front-loaded verb-resource structure. The optional flag is integrated compactly. Every sentence/word earns its place; no redundancy.

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

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

For a 2-param simple getter with no output schema, the description is sufficiently complete. It implies a return of application details and covers the main variant (with/without job listing). Sibling tool names add context, though the description alone could clarify the return type explicitly.

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

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

Input schema covers both parameters with detailed descriptions (100% coverage). The tool description mentions 'full job listing' and 'etc.', adding little beyond the schema. Baseline 3 is appropriate since 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?

Description uses specific verb 'Get' with resource 'specific job application by ID', clearly indicating a single-record read. It distinguishes from siblings like list_applications (list) and get_job (job listing), making the purpose unambiguous.

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

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

The phrase 'by ID' implies retrieval of one application, which distinguishes it from list_applications. It does not explicitly name alternatives or exclusions, but the context signals (sibling tools) and the optional includeJobListing parameter provide clear 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?

With no annotations provided, the description carries the burden of disclosing behavior. It indicates this is a read operation ('Get... Returns contact info') and mentions the output's purpose, but it does not specify the structure of the returned data, any authentication requirements, rate limits, or potential errors. This is adequate for a simple getter but not fully transparent.

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

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

The description is two concise sentences, front-loaded with the primary action and followed by a clarifying statement about the output. There is no redundant or extraneous content, making it an efficiently structured description.

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

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

The tool is very simple (one parameter, no output schema, no annotations), and the description conveys the core purpose and output type ('contact info for reaching out'). While it does not list exact fields in the return payload, the phrase 'contact info' is sufficiently indicative for most use cases. Given the low complexity, the description is reasonably complete, though explicit return fields would have made it a 5.

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% coverage—the only parameter, applicationId, is described as 'The job application ID.' The tool description adds the context that it applies to a 'saved' application, which slightly clarifies the parameter's meaning, but overall it adds little beyond the schema. Therefore, baseline 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 uses a specific verb ('Get') and resource ('recruiters for a job application'), clearly distinguishing it from sibling tools like get_job_recruiters (which targets jobs, not saved applications) and get_application_referrers (which returns referrers, not recruiters). It also states the purpose of the returned data ('for reaching out'), making the tool's function unambiguous.

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

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

The phrase 'for a job application you have saved' establishes the context of when to use this tool: when you need recruiters associated with an already-saved application. It implicitly distinguishes from get_job_recruiters, but it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that it returns people, without mentioning that the limit is capped at 2, whether the operation is read-only, or any edge cases like no referrers found. This lack of behavioral detail is a notable gap for a tool with no safety annotations.

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

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

The description is two sentences with no fluff. It front-loads the action ('Find') and provides a quick summary of the return value. 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 tool with two parameters and no output schema, the description covers the core function and return type. However, it omits the fixed limit behavior and does not hint at the response format beyond 'people', which would be helpful given no output schema is present.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema; it mentions the application relationship but doesn't explain the limit parameter's odd constraint (default 2, max 2) or how limiting works.

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 finds potential referrers for a job application, with a specific verb ('find') and resource ('referrers for a job application'). It distinguishes itself from siblings like get_job_referrers by explicitly scoping to 'a job application' rather than a job posting, and from get_application_recruiters by focusing on referrers instead of 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?

The description provides clear context for when to use the tool: when you have a job application and want potential referrers. It implies the need for an applicationId. However, it does not explicitly mention alternatives or exclusion criteria, such as using get_job_referrers for job-level referrers.

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. It discloses a key behavioral trait: performance ('much faster than paginating') and the nature of the response (aggregated counts, auto-apply metrics). However, it does not mention potential side effects, permissions, or data freshness, which is a minor gap for a read-only aggregation 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 concise sentences. The first sentence front-loads the purpose, and the second adds a comparative advantage. There is no wasted words or redundant information.

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

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

For a simple aggregation tool with two optional parameters and no output schema, the description provides a clear picture of what the tool does and when to use it. It mentions the kind of data returned (counts by status, auto-apply metrics) but does not detail the exact response structure, which is a slight gap given the lack 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% for both parameters (jobHuntId and dateOffset), and both have clear descriptions in the schema. The tool description adds no extra parameter-specific context beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Get aggregated stats for your job applications — total counts by status and auto-apply metrics.' It uses a specific verb and resource, and explicitly distinguishes it from the sibling tool list_applications by emphasizing aggregated stats over paginated listing.

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

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

The description provides explicit usage guidance: 'Much faster than paginating through list_applications.' This tells the agent when to choose this tool over an alternative, based on the need for aggregate data rather than individual records. It names the alternative and the performance benefit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the tool retrieves balance and usage information, implying a read-only operation, but it does not explicitly confirm safety, authentication requirements, or what 'usage information' includes. The verb 'Get' gives some hint, but more explicit transparency would be better.

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

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

The description is a single concise sentence that is front-loaded with the verb and resource. It contains no extraneous words and communicates the essential purpose efficiently.

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

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

Given the tool's simplicity (no parameters, no output schema, no annotations), the description provides adequate context: it tells what data is returned. It could be slightly more specific about the nature of 'usage information' (e.g., time period, units), but for a simple balance getter, this is sufficient.

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

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

The tool has zero parameters, so the input schema is fully covered vacuously. The description adds context about what the result pertains to (credit balance and usage), but there are no parameter meanings to clarify. A baseline of 4 is appropriate for a no-parameter tool.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource: your current credit balance and usage information. This distinguishes it from siblings like get_profile or get_salary, which target 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?

The description clearly implies when to use the tool: when you need to check your current credit balance or usage. While it doesn't explicitly mention alternatives or when not to use it, the context is unambiguous for a simple getter tool.

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

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

With no annotations, the description carries the full burden. It discloses the data returned (codes, symbols, units) and the intended workflow (pre-salary update), which is sufficient for a read-only list. It does not mention auth or rate limits, but those are unlikely to be concerns for a simple getter.

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 the primary action and output. Every word earns its place; no fluff.

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

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

For a zero-parameter, no-output-schema list tool, the description fully covers what the tool does and why to use it. It is 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?

There are zero parameters, and schema coverage is 100% (empty schema). The description adds value by clarifying the purpose and output of the tool, which is more than the schema provides. Baseline for 0 params is 4.

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

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

The description states a specific verb ('Get') and resource ('list of supported currencies') with the details it returns (codes, symbols, units). It clearly distinguishes this tool from all sibling tools, none of which deal with currencies.

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: 'Use this to look up the correct currency code before updating salary.' This gives a concrete scenario and implies no other tool needed for this purpose.

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. 'Get' implies a read-only operation, and the description adds the useful behavioral detail that the response includes a download URL. However, it does not disclose response format, pagination, or any other side effects, which is adequate for a simple get but not rich.

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

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

The description is a single, front-loaded sentence with no wasted words. It clearly states the action and key output (download URL), making it highly efficient.

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

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

For a simple get operation with one parameter and no output schema, the description is largely complete. It mentions the download URL as a key detail, but 'details' is somewhat vague. Given the tool's simplicity, the description is nearly sufficient, with little missing.

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

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

The input schema has 100% coverage for the single required parameter ('id'), and the description aligns with it by referencing a 'specific AI-generated resume'. The description adds no additional semantic detail beyond what the schema already provides, so a baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('details of a specific AI-generated resume') and highlights the download URL. It clearly distinguishes from sibling tools like get_resume and list_generated_resumes by targeting AI-generated resumes specifically.

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 clearly implies when to use this tool: when you need details of a specific AI-generated resume. However, it does not explicitly state when not to use it or mention alternatives, though sibling tools make this contextually obvious.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It indicates a read-only, list-returning operation ('Get the list') and the nature of the values ('valid'), but does not disclose details such as output format, sorting, or any potential pagination. For a simple, parameterless lookup, this is adequate but not rich.

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

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

The description is two sentences: the first states the primary purpose, the second explains where to use the values. It is concise, front-loaded, and every sentence earns its place without unnecessary detail.

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

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

This is a simple, parameterless lookup tool with no output schema. The description fully covers what the tool does and how to use the result in the broader workflow, making it complete for the tool's complexity and 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 tool has zero parameters, so the schema fully covers parameter semantics. The baseline for 0 params is 4, and the description adds contextual meaning by explaining how the returned values will be used as filter inputs in other tools, which is helpful beyond the empty schema.

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

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

The description clearly states the tool's function: 'Get the list of valid company industries' with a specific verb ('Get'), resource ('list of valid company industries'), and a clear domain distinct from sibling tools like get_currencies or get_profile. It defines exactly what is returned and the scope ('valid company industries').

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 on when to use the tool: to retrieve values for the 'industries' filter in search_jobs, create_job_hunt, or update_job_hunt. It names specific integration points, giving clear usage guidance, though it does not explicitly state when not to use the tool or mention alternative 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. It discloses that the tool returns full job posting details including description, salary, skills, and company info, and it clarifies the ID type (job listing ID vs application ID). It does not mention potential errors or permission requirements, but for a read-only get operation, the behavior is adequately transparent. Slight deduction for not stating that the job must exist or that it returns a single object.

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, zero fluff. The first sentence states the core purpose and the ID distinction. The second gives the alternative tool. The description is front-loaded and every sentence earns its place.

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

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

With no output schema, the description communicates what the response includes (description, salary, skills, company info). It also differentiates from get_application. It does not describe error behavior or authorization requirements, but for a simple get-by-id tool, this is a reasonably complete description. Slight gap: no mention of what happens if the ID is invalid.

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

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

The schema only describes the parameter as 'The job ID'. The description adds crucial meaning by specifying it is the 'job listing ID (not application ID)', which resolves a likely ambiguity in a domain with multiple ID types. It also implies the ID should identify a job posting. This exceeds 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 retrieves detailed information about a specific job listing/posting, naming the resource and the action. It explicitly distinguishes itself from get_application by specifying that it uses the job listing ID, not the application ID, which separates it from a key sibling tool.

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?

It explicitly says 'Use this to view the full job posting details' and provides a direct alternative: 'For job application details, use get_application instead.' This gives clear when-to-use and when-not-to-use guidance with a named sibling tool.

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

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

With no annotations, the description carries full burden for behavioral disclosure. 'Get details' implies a read operation, but there is no mention of response contents, error/not-found behavior, or permission requirements. It adds minimal behavior context beyond the verb.

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

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

A single, concise sentence that is front-loaded with the action and resource. No filler or redundant phrasing.

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

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

For a simple single-parameter getter, the description is minimally viable but leaves the return 'details' unspecified. Without an output schema, it would benefit from naming at least a few example fields or stating it returns the full job hunt object.

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

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

Schema coverage is 100% for the single 'id' parameter, and the description repeats that the parameter is an ID without adding format, source, or usage details. The schema already provides the meaning, so no additional compensation is needed.

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

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

The description clearly states a specific verb ('Get') and resource ('details of a specific job hunt'), with the scope ('by ID') distinguishing it from list_job_hunts and other resource-specific getters like get_job.

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

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

The description implies usage when a known job hunt ID exists, but does not explicitly mention alternatives like list_job_hunts for finding IDs or contrast with update_job_hunt. Usage context is present but no exclusions or alternatives are named.

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

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

With no annotations, the description carries the full burden. It discloses return content ('contact info including email and LinkedIn') and implies a read-only operation via 'Get.' While it doesn't explicitly state side-effect freedom, it's a simple retrieval tool and the description provides the key behavioral information.

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: the first states the main action and scope, the second describes return value. No wasted words, 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 simple one-parameter tool with no output schema, the description adequately explains what it does and what it returns. However, it lacks explicit guidance on when to choose this over similar tools like get_application_recruiters, which would improve completeness.

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

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

The input schema has 100% coverage for the single parameter (jobId) with a clear description. The tool description does not add further semantic detail about the parameter, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Get recruiters who posted or are associated with a specific job.' It uses a specific verb and resource, and the mention of contact info distinguishes it from related tools like get_job_referrers or get_application_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?

The description implies usage context (when you need recruiters for a job) but does not explicitly differentiate from sibling tools like get_application_recruiters. There is no mention of when not to use this tool.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states that the tool returns people based on your network and the job, but does not mention important behavioral traits like whether it requires authentication, what happens when no referrers are found, or any limits on results. It also doesn't explicitly state it's a read-only operation, which is a significant gap given the absence of annotations.

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

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

The description consists of two concise, front-loaded sentences that immediately convey the tool's purpose and output. Every word earns its place with no unnecessary filler or repetition.

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

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

For a simple read-only tool with only two parameters and no output schema, the description is adequate but not fully complete. It explains what the tool does and generally what it returns, but doesn't describe the shape of the returned data or mention the limit parameter's behavior. The lack of an output schema makes the return structure disclosure more important, and the description 'people who might be able to refer you' leaves ambiguity about the exact fields.

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%, meaning both jobId and limit are already documented in the schema. The description does not add parameter-specific details beyond what the schema provides, so the baseline score of 3 applies. It does implicitly reference jobId by saying 'for a specific job,' but adds no new semantic value for either parameter.

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

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

The description clearly identifies the tool's purpose: finding potential referrers at a company for a specific job. It uses specific verbs ('Find,' 'Returns') and distinguishes the resource (referrers) from related sibling tools like get_job_recruiters and get_application_referrers, though it doesn't name these alternatives explicitly.

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

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

The description implies when to use the tool ('for a specific job' and 'based on your network'), but provides no explicit guidance on when not to use it or what alternatives exist. It lacks clear exclusions such as 'for recruiters use get_job_recruiters' or 'for an application use get_application_referrers'.

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 states the action and content but does not explicitly confirm read-only behavior, authentication requirements, or absence of side effects. The word 'your' implies scope but is not explicit about 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 a single, concise sentence that front-loads the verb and resource. Every word contributes meaning with no redundancy.

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

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

The tool has no parameters and no output schema, so the description must explain return content. It lists four content categories, which gives a reasonable picture. However, it could mention whether the response includes any additional metadata or format, but for a simple profile getter this is adequate.

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

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

The tool has zero parameters, and the schema coverage is 100% (vacuously). The baseline for 0 parameters is 4, and the description adds no unnecessary parameter information, which is appropriate.

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

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

The description clearly states the action (Get) and the resource (user profile), and lists specific content areas (personal info, skills, experience, work history). This distinguishes it from sibling tools like update_profile and get_job.

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

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

The description implies usage for retrieving the user's profile but does not explicitly contrast with alternatives like update_profile or mention when not to use it. No exclusions or alternative tool references are provided.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only says 'Get details' and mentions the download URL, but does not disclose that includeRawTxt controls raw text inclusion, any auth/permission requirements, or the nature of 'details'. The optional parameter behavior is left entirely to the schema.

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

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

The description is a single concise sentence that front-loads the action and resource. Every word earns its place, with no redundant information or filler.

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

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

This is a simple get operation with full schema coverage for parameters. The description mentions the download URL as a key return value, but does not explain the includeRawTxt behavior or what other 'details' are included. Given the absence of an output schema, a bit more detail would improve completeness, but the description remains minimally viable.

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

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

The input schema already provides descriptions for both parameters (id, includeRawTxt) with 100% coverage. The description adds no additional meaning beyond the schema, so a baseline of 3 is appropriate.

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

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

The description clearly states a specific verb ('Get') and resource ('details of a specific uploaded resume'), and highlights a key output (download URL). It distinguishes from siblings like list_resumes (listing multiple) and get_generated_resume (generated resumes), making the tool's purpose unambiguous.

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

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

The description provides no guidance on when to use this tool vs alternatives such as list_resumes or get_generated_resume. No exclusions, prerequisites, or contextual cues are given, leaving the agent to infer usage solely from the name.

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

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

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?

With no annotations, the description carries the burden of disclosing behavioral traits. It mentions the main side effect: 'Optionally trigger auto-apply immediately', which is important. However, it lacks details about handling duplicate jobs, error conditions, or permission 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 two sentences, front-loaded with the main action, and has zero waste. Every phrase serves a purpose: what it does, supported examples, optional side effect, and when to use.

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 3-parameter tool with 100% schema coverage, the description adequately covers the main workflow and use case. It doesn't explain return values, but since no output schema exists, the core functionality and trigger conditions are sufficiently described.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds mild value by clarifying that the URL is a direct link to a job posting and that autoApply is optional, but it doesn't add syntax or format details beyond the schema.

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

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

The description clearly states the specific action: 'Import a job from a URL' and 'add it to your applications', distinguishing it from siblings like add_job_to_applications that don't use URLs. The mention of supported platforms (LinkedIn, Greenhouse, etc.) adds 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?

The description provides a clear usage context: 'Use this when a user has a direct link to a job posting.' It doesn't name explicit alternatives or exclusions, but the context is sufficient for an agent to know when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It states it lists applications but gives no details on authentication, response format, pagination defaults, or sorting behavior. The 'list' verb implies a read operation, but no safety or behavioral context is disclosed.

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

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

A single, efficient sentence with no redundant content. It front-loads the action and resource, and the filter options are stated compactly.

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

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

The description is adequate for a simple list tool, but without annotations or an output schema, it lacks details about return structure and default pagination behavior. The schema covers parameter documentation, so the tool is callable, but an agent might not know what fields are in the response.

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 all four parameters (page, limit, status, jobHuntId) documented in the schema. The description adds a concise summary of filtering by job hunt or status but does not introduce additional parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool lists job applications and mentions optional filters by job hunt or status. However, it doesn't explicitly distinguish from sibling tools like get_application or list_interviews, though 'list' implies collection.

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

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

No guidance is given on when to use this tool versus alternatives such as get_application or list_interviews. No exclusions, prerequisites, or alternative tool references are provided.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds context about the resume type (AI-generated, tailored for specific job applications), but does not describe return format, pagination, or other behavioral traits. It does not contradict any annotations.

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

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

The description is two sentences, front-loaded with the verb and resource, and the second sentence clarifies the tool's scope without redundancy. Every word earns its place.

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

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

The description does not differentiate this tool from the sibling list_resumes, and with no output schema, it lacks information about the return structure. The schema covers filters, but the overall context is incomplete for an agent to choose 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 describes both optional parameters (manualTrigger and jobApplicationId) with 100% coverage, so the baseline is 3. The description adds nothing about parameters, but the schema is sufficient.

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

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

The description clearly states the action ('List') and the resource ('AI-generated custom resumes'), and explains that these are automatically tailored for job applications. This distinguishes it from the sibling tool list_resumes, which likely lists all resumes.

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

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

The description implies usage context by defining the resume type ('AI-generated custom resumes' tailored for job applications), but it does not explicitly say when to use this tool versus alternatives like list_resumes, nor does it provide exclusion criteria.

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

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

No annotations are provided, so the description carries the burden. It discloses that the data is sourced from email confirmations and that only 'actively tracked' interviews are listed. The verb 'list' implies a read-only operation, which is further supported by the non-mutating tone. It does not detail side effects or permissions, but for a list tool this is acceptable. It adds useful context about the data source.

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

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

The description is exactly two sentences, front-loaded with the primary action ('List job interviews'), and every clause adds value: data source, active tracking, and parameter usage. No filler or redundancy.

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

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

The tool has 5 parameters and no output schema. The description covers the data source, the primary filter semantics, and the tracking scope. It does not describe the return format, but for a simple listing tool this is a minor gap. The parameter schema handles the input details comprehensively, so the description is adequate for the tool's complexity.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description adds a usage hint for 'upcoming=true' and mentions filtering by application ID or status, but these repeat the schema's descriptions rather than adding new meaning. The baseline of 3 applies; no extra value beyond the schema is provided.

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

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

The description begins with a clear verb+resource: 'List job interviews'. It further specifies that interviews are actively tracked by JobGPT and detected from email confirmations, which clearly distinguishes this from sibling tools like list_applications or list_outreaches. No ambiguity.

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

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

The description provides explicit usage guidance: 'Use upcoming=true to get scheduled/rescheduled interviews' and 'Can also filter by application ID or status.' This tells the agent when to use specific parameters. It doesn't exclude alternatives, but there is no competing interview-listing tool among siblings, so the context is sufficient.

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 clearly indicates that this is a read operation ('List') and mentions the additional credits balance. However, it does not disclose details like pagination behavior, ordering, or whether any side effects occur. The behavior is straightforward, but additional context could be helpful.

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, immediately stating the main purpose and then the additional credits balance. No filler or redundant information. It is well-structured and front-loaded.

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

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

For a simple list tool with two optional parameters and no output schema, the description is sufficiently complete. It states the primary return (job hunts) and the secondary return (credits balance), covering the essential information. It could mention pagination details, but these are not critical for this straightforward 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 input schema already provides descriptions for both parameters (page and limit), achieving 100% coverage. The tool description adds no further parameter details, so the baseline score of 3 is appropriate. The schema adequately explains the purpose and defaults for each parameter.

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

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

The description clearly states the tool's function: listing saved job hunts, with a specific verb and resource. It also adds the secondary function of returning the credits balance. This distinguishes it from siblings like get_job_hunt and create_job_hunt.

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 implicitly conveys when to use this tool: whenever you need to list your saved job hunts. It does not explicitly exclude alternatives, but the context is clear. Sibling tools like get_job_hunt imply a more targeted use case, though no direct comparison is made.

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

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

No annotations are provided, so the description must carry the behavioral burden. It discloses that only sent emails are listed, which is a useful scope constraint. However, it does not mention pagination behavior, return format, or explicitly confirm read-only status beyond the verb 'list'.

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

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

The description is a single, front-loaded sentence that conveys the action and resource without any unnecessary words. It is 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?

For a simple list tool with all parameters documented in the schema, the description adequately states the resource and scope. It lacks explicit return-structure details, but the absence of an output schema makes this a minor gap rather than a critical omission.

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

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

All three parameters (page, limit, jobApplicationId) are fully described in the schema with defaults and meaning, so the schema provides 100% coverage. The description adds no additional parameter semantics, so 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 explicitly states 'List your outreach emails that have been sent to recruiters and referrers,' using a clear verb ('List') and specific resource ('outreach emails'). It distinguishes itself from siblings like send_outreach by focusing on retrieval, and from other list tools by targeting outreach-specific 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 clearly implies this is for viewing sent outreach emails, which is distinct from sending them (send_outreach). It doesn't explicitly name alternatives or exclude other contexts, but the resource type is unambiguous, so the usage context is clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does reveal that the tool returns all uploaded resumes including primary and alternates, but it does not mention authentication requirements, pagination, or the effect of the includeRawTxt parameter on response size/content.

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 long, front-loaded with the action 'List your uploaded resumes,' and contains no redundant or unnecessary information. Every phrase contributes meaning.

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

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

This is a simple list tool with one optional boolean parameter, and the description adequately states the scope (all uploaded resumes) and output intent (returns resumes). It lacks a contrast with list_generated_resumes and does not describe the response format, but given the low complexity, this is fairly complete.

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

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

The input schema fully documents the only parameter includeRawTxt with a default value, so the schema_description_coverage is 100%. The description adds no additional parameter-level meaning, so 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 opens with 'List your uploaded resumes,' which is a specific verb-resource pairing. It further clarifies scope by including 'primary resume and any alternate versions' and uses 'uploaded' to distinguish from the sibling list_generated_resumes.

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 clearly implies use when the caller needs a list of uploaded resumes, but it does not explicitly name alternatives or state when not to use it. Given the sibling list_generated_resumes, a direct contrast would have made the guidance more 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, the description carries the full burden. It discloses important behavioral traits: it uses saved job hunt filters (titles, locations, skills, salary, etc.) and returns only jobs not already seen, applied to, or rejected. This adds value beyond the tool name. It doesn't mention pagination or error handling, but the core behavior is well covered.

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

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

The description is two sentences, front-loaded with the primary purpose. The second sentence adds key behavioral details and a pointer to update_job_hunt. There is no redundant or extraneous text.

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

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

Given no output schema and no annotations, the description sufficiently explains the tool's function, filtering behavior, and prerequisite for changing filters. It implies a list return ('only returns jobs'), which is clear enough for an agent. It does not explicitly state return format or edge-case behavior, but for its complexity it is fairly complete.

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

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

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds some contextual info (e.g., that jobHuntId references the saved configuration with filters), but it does not meaningfully extend the schema's parameter descriptions. No additional semantics are needed.

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: 'Get new job matches based on a saved job hunt configuration.' It uses a specific verb ('Get') and names the resource (job matches tied to a job hunt). It distinguishes from siblings like search_jobs by referencing the saved configuration and the filtering of 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?

It gives clear context for when to use the tool (when you want new matches from a saved job hunt) and explicitly points to update_job_hunt for changing filters. However, it does not explicitly state when not to use it (e.g., for ad-hoc searches, use search_jobs), so it lacks a bit of alternative guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 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?

With no annotations, the description must disclose behaviors. It states the email will be sent from the user's configured email, a meaningful detail. But it does not mention irreversibility, possible failure modes, or whether sent emails are logged, leaving some ambiguity 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 two sentences, starts with the action, and contains no redundant or filler words. Every sentence adds value: the first defines the action and target, the second clarifies the sender.

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 send-action tool, the description covers the core purpose and the key behavioral constraint (configured email). It lacks details about expected response or side effects, but the lack of an output schema and the simple parameter set make this mostly sufficient.

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

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

Schema coverage is 100% with each parameter described (e.g., contactId includes the source functions). The tool description itself adds no parameter-specific semantics beyond the schema, so it meets the baseline but does not exceed it.

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

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

The description uses a specific verb+resource construction: 'Send an outreach email to a recruiter or referrer for a job application.' This clearly distinguishes it from sibling tools like apply_to_job (formal application) and list_outreaches (viewing sent outreach).

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 establishes the context (outreach for a job application) and the contactId parameter description explicitly points to get_application_recruiters or get_application_referrers as sources. However, it does not explicitly state when not to use this tool or name alternatives.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It only says 'Update' without mentioning side effects, whether it partially updates or replaces existing data, return values, permission requirements, or error behavior. This is minimal for a mutation tool.

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

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

The description is a single, compact sentence with no wasted words. It front-loads the purpose and is immediately scannable.

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 (3 params, no output schema), the description covers purpose and parameter names, but lacks behavioral information like return values or side effects. The schema fills parameter details, but no annotation/description covers the effects of the update. It's minimally sufficient but not comprehensive.

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

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

Schema coverage is 100%, and the description adds no meaning beyond the schema. The description 'status or notes' merely mirrors property descriptions. Since the schema already explains params clearly, baseline 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Update a job application status or notes'. It distinguishes from siblings like get_application (read) and apply_to_job (create) by specifying the update action on the same resource.

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

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

The description implies usage (when you need to update application status or notes) but provides no explicit when-to-use vs alternatives, prerequisites, or exclusions. There is no mention of using get_application for viewing or other related tools.

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

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

With no annotations 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.