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

With no annotations, the description fully carries the behavioral burden. It discloses key non-obvious behaviors: times are in employee's local time with a specific format, entries must be in open sequences, and module prerequisites. This goes beyond the simple 'add' verb and helps the agent understand operational constraints. It doesn't elaborate on error handling, but for a create operation, the stated preconditions and time semantics are substantial.

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 three sentences, each earning its place: the first states the action, the second provides time format and constraints, and the third covers employee identification. It is front-loaded and avoids redundancy, making it easy to parse quickly.

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

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

For a creation tool with 9 parameters and no output schema, the description covers the essential context: preconditions (open sequence, module enabled), time handling, and employee identification. It does not explain return values or error scenarios, but given the schema richness and the tool's straightforward CRUD nature, this is adequate for an agent to select and invoke it correctly. A perfect score would require either an output schema or additional edge-case behavior disclosure.

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 all 9 parameters have individual descriptions. The description itself adds little beyond the schema: it restates the time format and identification alternatives, which are already in the schema. The baseline for full schema coverage is 3, and the description does not significantly enrich parameter understanding beyond what the schema provides.

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

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

The description opens with 'Add a timesheet/timeclock entry for an employee,' which uses a specific verb and resource, clearly distinguishing it from sibling tools like list_timesheets and get_timesheet. It also specifies the scope (employee-level) and object type (timeclock entry), leaving no ambiguity about the tool's function.

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 conditions for use: entries can only be added to OPEN timesheet sequences, and the timeclock module must be enabled for the company and the employee's template. It also clarifies how to identify the employee (employee_code or employee_email). While it doesn't explicitly compare to alternatives, the constraints give clear guidance on when this tool is applicable versus when another tool like list_timesheets might be used first.

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 behavioral traits. It explicitly warns that the deletion 'cannot be undone', which is critical for a destructive operation. It does not mention any other side effects or permissions, but the permanent nature is well highlighted.

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 and front-loaded, consisting of two short sentences with no filler. Every word contributes to understanding the tool's purpose and a key warning.

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 delete tool with one parameter and no output schema, the description is fully adequate. It states what it does, how identification works, and the irreversibility, making it complete for an agent to select and invoke correctly.

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

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

Schema coverage is 100% for the single 'id' parameter, and the schema already describes it as 'The unique reminder ID to delete'. The description adds 'by its unique ID', which is marginal and does not provide additional semantic value 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 action ('Permanently delete') and the resource ('a reminder by its unique ID'). It directly distinguishes the tool from siblings like get_reminder and update_reminder by specifying deletion as the operation.

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

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

The description implies when to use the tool (when a reminder needs to be permanently removed) but does not explicitly mention alternatives or exclusion criteria. However, the context is clear enough for a simple delete operation.

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 safety/behavior disclosure burden. It does add context by noting that the response includes job applications with specific attributes, but it does not state whether the operation is read-only, what happens if the applicant is not found, or any permission requirements. This is adequate but lacks richness.

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

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

The description is one concise sentence (~20 words) that front-loads the primary purpose ('Get a single applicant') and efficiently includes key details about lookup and returned data. There is no extraneous or redundant content.

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

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

For a simple get-by-id tool with one parameter and no output schema, the description is fairly complete. It explains the resource, lookup key, and scope of returned data (applications with stage, scores, flags). Minor omissions like error handling or exact matching behavior are not critical given the tool's simplicity.

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% (the single parameter applicant_id is described as 'The unique applicant ID, or the applicant's email address'). The description essentially restates this, adding no new meaning or format details, so baseline 3 applies.

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

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

The description clearly states a specific verb ('Get') and resource ('a single applicant'), and further specifies the lookup by 'unique ID or email address' and the inclusion of 'job applications with stage, scores and flags'. This distinguishes it from siblings like list_applicants (multiple) and get_application (different resource).

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

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

The description implies when to use the tool (when a single applicant's details, including applications, are needed) but does not explicitly mention alternatives or exclusions. For example, it doesn't say 'for multiple applicants, use list_applicants', but the context is clear enough.

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 lists the data returned, which gives useful context about the tool's behavior, but omits any detail on authentication, error handling, or performance. 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?

The description is a single, well-organized sentence that front-loads the primary action and resource, then lists the included data. It is concise, with no filler or redundancy.

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

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

For a simple get tool with one parameter and no output schema, the description provides sufficient context: what it does, what data is returned, and how to find the ID. It could mention behavior for nonexistent IDs, but that is not typically essential for a get operation.

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

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

The schema already covers the single parameter with a clear description ('The numeric application ID'), and the tool description only repeats that it is numeric. Since schema coverage is 100%, the description adds no additional semantic value 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 tool retrieves a single job application by ID, listing the specific data included. This distinguishes it from sibling tools like list_applications (which returns many) and save_application (which writes). The verb and resource are explicit.

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

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

The description advises using list_applications to find application IDs, providing an explicit alternative for a related workflow. It implies this tool is for when you already have a specific ID, though it does not explicitly say 'use this when you need full details of one application' or mention any exclusions.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals the maximum 500 records per response and suggests filtering, but doesn't disclose other behavioral traits like sorting, default date range, or what happens if the limit is exceeded. A 3 reflects that some useful behavior is disclosed but key details are missing.

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

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

The description is two sentences long, immediately states the tool's purpose, and then presents the critical limit with actionable advice. Every word earns its place; there is no redundancy 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?

For a 7-parameter tool with no output schema and no annotations, the description could be more complete. It does convey the core use case and the record limit, but it doesn't explain the return record structure, sorting, or default behavior when filters are omitted. A 3 is appropriate because it's a viable minimal description that leaves room for ambiguity.

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

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

Schema description coverage is 100%, so the description isn't required to explain individual parameters. However, it adds meaning by framing the filters as essential to stay under the 500-record cap, which clarifies the purpose and recommended usage of filter parameters like job, applicant, and changed_at ranges.

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' with a clear resource: 'history of job applications moving between recruitment pipeline stages.' This distinguishes it from sibling tools like get_application or list_applications, which handle application details rather than stage tracking history.

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 practical context by noting the 500-record limit and advising the use of filters, which guides when and how to use the tool effectively. It doesn't explicitly address when not to use it versus alternatives, but the tool's unique purpose among siblings makes that less critical.

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

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

No annotations are provided, so the description carries the full burden. It implies a safe read operation via 'Get' and lists expected return fields, but does not explicitly state that no data is modified or disclose error/authentication behavior. 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?

Two sentences, front-loaded with the verb and resource, and zero filler. The first sentence states what it does, the second adds the primary use case. Every word earns its place.

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

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

For a simple read tool with two clear optional parameters and no output schema, the description covers the key returned fields and a practical use case. It lacks any mention of alternative tools for more detailed company data, but none appear in the sibling list, so the description is sufficiently complete.

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

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

Schema description coverage is 100%, with both optional boolean parameters fully described. The tool description itself does not mention the parameters, but the schema already provides clear semantics, 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 uses a specific verb ('Get') and resource ('basic company information from HR Partner'), listing concrete data points (company name, subscription status, expiry, employee counts, timezone). This clearly distinguishes it from sibling tools that target employees, applications, or leaves.

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 use case ('validating the API key is connected to the correct company'), which is helpful context. It does not explicitly mention alternatives or when not to use, but the context is sufficient for a read-only informational 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 must carry the full burden of behavioral disclosure. It states output contents but does not address permissions, side effects, error behavior, or any caveats. 'Get' implies read-only, but there is minimal behavioral context beyond that implication.

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 wasted words. It front-loads the purpose in the first sentence and provides the usage hint in the second, making it easy to scan and understand.

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 tool without an output schema, the description adequately covers the purpose and the contents of the returned data. It could be more explicit about the exact return structure or error scenarios, but the listed detail categories soften this gap.

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

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

The schema already documents the single 'code' parameter clearly with examples. The description adds valuable context by indicating the code comes from list_employees, which aids correct invocation beyond what the schema provides. Coverage is 100%, so the description meaningfully supplements 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 clearly states the tool's purpose: 'Get full details for a single employee by Employee Code', specifying the resource (employee) and the key identifier. It also lists what details are included (contact details, addresses, tags, custom fields), and the verb 'get' distinguishes it from list_employees and other sibling tools.

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

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

The description explicitly instructs to 'Use list_employees first to find employee codes', providing a clear workflow and a named prerequisite tool. It does not explicitly state when not to use this tool or name other alternatives, but the prerequisite guidance gives solid context for correct usage.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that the response includes selection panel, custom application form definition, scorecard, pipeline stages, and full text/web content, providing useful context about what to expect from the call.

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 tight sentences: the first packs purpose and return details, the second offers a pointer to list_jobs. No redundant words.

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

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

For a single-parameter get tool with no output schema, the description is remarkably complete: it specifies the input format, the scope (single listing), and enumerates the major response components. It also tells the user how to obtain the ID.

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

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

The schema already fully documents job_id as 'The unique job listing ID or slug' (100% coverage). The description adds a concrete example ('forklift-driver-oz0H') and reinforces the slug format, adding value 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 'Get a single job listing by its unique job ID/slug' with a specific verb (Get) and resource (job listing). It also lists key fields included (selection panel, scorecard, etc.), distinguishing it from sibling list_jobs and other get_* tools.

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

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

The description explicitly names list_jobs as the way to find job IDs, providing a clear pointer to an alternative. It implies this tool is for single job retrieval when full details are needed, though it doesn't explicitly state when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It lists the types of data included (approver action history, approval conditions, extended employee details, file attachments), giving a clear picture of the return content. It doesn't mention permissions or error cases, but for a read-only get operation, this is reasonably 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 exactly two sentences, front-loading the primary function in the first sentence and adding a helpful pointer to the sibling tool in the second. Every word earns its place, with no redundancy 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 single-get tool with one required parameter and no output schema. The description compensates for the missing output schema by enumerating key return components and provides a clear next-step for ID discovery. It could mention error behavior, but the context is sufficiently complete for the tool's complexity.

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

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

The schema already describes the only parameter 'id' with 100% coverage ('The unique leave request ID'). The description adds no additional parameter-level syntax or format details, but simply reinforces that the tool fetches by ID. The baseline of 3 is appropriate given full schema coverage.

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

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

The description clearly states the tool retrieves a single leave request by ID, using a specific verb and resource. It distinguishes itself from list_leave_requests by explicitly mentioning the need to find IDs first, making the purpose unmistakable.

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

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

The description provides explicit usage guidance by telling users to 'Use list_leave_requests to find IDs,' which both clarifies when not to use this tool (when you lack an ID) and directs them to the appropriate alternative. This is a strong example of when/when-not guidance.

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

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

No annotations are provided, so the description must carry the burden. It mentions one behavioral aspect (detailed view includes relationships) but does not disclose that this is a safe read operation, any authentication requirements, or return format. For a read-only tool, this is a noticeable gap.

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

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

Two short sentences, front-loaded with the main purpose. Every word earns its place; no redundancy 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?

The tool is simple with two optional params fully described in the schema. The description covers the core purpose and the main optional behavior. Missing details like response format or read-only nature, but for a straightforward GET tool, it's 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?

Schema coverage is 100% with detailed parameter descriptions, so the baseline is 3. The description adds no extra parameter semantics beyond what the schema already provides, 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 resource and action: 'Get the document library category list.' It also specifies the optional 'detailed' view, adding specific scope. This distinguishes it from sibling tools like get_library_documents and get_lookup.

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 detailed view ('also includes parent and child category relationships') but provides no explicit guidance on when to choose this tool over alternatives or any exclusion criteria. Usage context is present but not fully developed.

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 the returned fields and hints that max_records is a client-side limit via schema, but does not mention authorization, rate limits, or whether all documents are always returned regardless of user permissions. This is acceptable for a simple read operation but not rich detail.

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

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

A single, front-loaded sentence that states the action, optionality, and outputs with no redundant words or repetition of schema content. Every phrase 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 adequately covers purpose, optional filter, and return fields, which is sufficient for a simple list tool without an output schema. It lacks information about potential errors or authorization, but given the simplicity and 0 required params, it 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?

Schema coverage is 100% with both parameters described in detail (max_records limit behavior, category_slug purpose and link to get_library_categories). The tool description adds only marginal reinforcement of these facts, 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 uses a specific verb-resource pair ('Get documents from the HR Partner document library') and clearly identifies the scope (policies, handbooks). It also lists the return values (description, download URL, size, timestamps), making it distinct from sibling tools like get_library_categories.

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 it (for library documents) and mentions its optional category filter, pointing to get_library_categories for slugs. However, it does not explicitly state when not to use it or name alternatives, leaving a small gap in 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, the description carries the full burden for safety disclosure. It explicitly states 'Lookups are read-only via the API,' clearly conveying that this tool has no side effects. This adds behavioral context beyond the parameter schema.

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

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

The description is two sentences, front-loaded with the primary function, and includes usage context and a read-only note without any wasted words.

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

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

For a simple read-only tool with a single required enum parameter and an optional limit parameter, the description covers the purpose, usage context, and safety profile. It doesn't describe the return structure, but 'valid values' implies a list, and the schema fully documents parameters.

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

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

Both parameters are already documented in the schema with descriptions and an exhaustive enum for lookup_name, so the description adds little additional semantics. The tool description gives examples of lookup names, but these are already enumerable in the schema. Baseline 3 is appropriate given 100% schema coverage.

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

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

The description uses a specific verb 'Get' with a clear resource 'valid values for an HR Partner lookup list' and lists concrete examples, distinguishing it from sibling entity-specific tools. The phrase 'discover valid filter values for the other tools' further clarifies its role.

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

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

The description explicitly instructs to use this tool for discovering valid filter values for other tools, which is clear usage guidance. It does not mention when not to use or alternatives, but no sibling tool provides lookup values, so the guidance is adequate.

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

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

With no annotations, the description carries the full burden. It only restates that the tool fetches a single reminder by ID, which is essentially the tool's name plus parameter. It doesn't disclose return behavior, error handling, read-only status, or any side effects. The 'get' verb implies a read, but there's no explicit safety 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 two short sentences with no filler. The first sentence states the core purpose, and the second gives actionable guidance on finding IDs. 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 single-parameter getter with no output schema and no annotations, the description is minimal but functional. It covers the primary use case and points to list_reminders for ID discovery. However, it omits return format and error behavior, which are important in 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?

The schema already provides 100% coverage for the single parameter (id, type integer, with description). The description's 'by its unique ID' adds little beyond the schema's existing 'The unique reminder ID.' Therefore, the baseline of 3 is appropriate, as the description does not materially enhance parameter understanding.

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

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

The description clearly states the verb (get), the resource (a single reminder), and the identifying criterion (unique ID). This distinguishes it from sibling tools like list_reminders (listing) and update_reminder (modifying), so the purpose is unambiguous.

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

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

The description explicitly names list_reminders as the way to find reminder IDs, providing a direct alternative workflow. It implicitly communicates when to use this tool (when you have a specific ID) and when not (when you need to browse or search, use list_reminders).

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 return structure matches list_timesheets, which adds behavioral predictability, but it omits details about error conditions, read-only guarantees, or permissions.

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

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

One sentence that front-loads the purpose and immediately references the sibling for structure. No filler 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 two-parameter get tool with no output schema and no annotations, the description is fairly complete: it identifies the resource, scope, and relationship to list_timesheets. It lacks edge-case info but complexity is low.

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

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

The schema already describes both parameters with 100% coverage, including an example for sequence. The description adds no new parameter semantics, but the baseline 3 is appropriate given schema coverage.

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

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

The description clearly states 'Get a single employee's timesheet for one sequence (period)' with a specific verb and resource. It also distinguishes from the sibling list_timesheets by emphasizing 'single' and noting the same structure for one combination.

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 references list_timesheets as a source for sequence labels and contrasts this tool as returning a single record, implying usage for one specific employee/sequence. However, it doesn't explicitly state exclusions or when to prefer this over 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?

There are no annotations, so the description must disclose behavioral traits. It mentions included fields but omits important behavior: no pagination (the API itself does not paginate, as noted in max_records), potential performance impact of show_linked_request, default ordering, or what happens with no filters. This gap is significant for a tool with 16 parameters.

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

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

The description is a single, efficient sentence: 'Get employee absence records (leave taken, or TOIL/Flexi leave added).' Front-loaded with the action and resource, it conveys the core purpose and scope without unnecessary words. The second sentence lists included details, earning 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 16 parameters, no output schema, and no annotations, this is a complex tool. The description provides only a minimal overview and does not explain return formats, record structure beyond a few fields, pagination limitations, or the relationship to leave requests. This is insufficient for an agent to fully understand the tool's behavior without additional exploration.

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 detailed descriptions for all 16 parameters, so the baseline is 3. The description adds a high-level summary (e.g., 'TOIL/Flexi leave added') but does not provide deeper semantics beyond the schema. It does not compensate for any schema gaps because there are none, but it also does not elevate the understanding further.

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

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

The description states a specific verb and resource: 'Get employee absence records', and further clarifies the scope with 'leave taken, or TOIL/Flexi leave added' and the included fields (reason, status, dates, duration, physician/certificate details, attachments). This distinguishes it from sibling tools like list_leave_requests, which likely cover requests rather than absence records.

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

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

No explicit usage guidance is provided. The description simply says to get absence records but does not indicate when to prefer this over sibling tools such as list_leave_requests or when not to use it. The use case is only implied, with no exclusions or alternatives mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that the output is a 'flat list' and that it spans 'across employees,' which is helpful. However, it does not mention that the operation is read-only, potential performance implications of listing all addresses, or any details about the response format beyond flatness. Some behavioral context is added, but significant gaps remain.

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 exceptionally concise, using two short sentences to convey the core purpose and a key distinction from an alternative. Every word earns its place, with no fluff or repetition.

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

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

Given the simplicity of the tool (4 optional parameters, no output schema), the description plus schema provide sufficient context for an agent. The note about get_employee adds useful context about where individual addresses can be found, partially compensating for the lack of an output schema. It could be more explicit about the structure of address records, but overall it is adequately 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?

All 4 parameters are fully described in the schema (100% coverage), so the description does not need to add parameter-specific details. The description itself provides no additional parameter semantics beyond what the schema already offers, but due to high schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool returns a flat list of employee addresses across all employees, using a specific verb and resource. It also distinguishes itself from the sibling tool get_employee by noting that individual addresses are included in that response, which helps differentiate the tool's purpose.

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

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

The description provides clear context for when to use this tool (when a flat, cross-employee list is needed) and explicitly mentions an alternative (get_employee for individual addresses). It does not list exclusions or more nuanced when-not-to-use scenarios, but the guidance is clear enough for tool selection.

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

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

With no annotations, the description carries the transparency burden. It discloses a key behavioral trait (only active, non-terminated employees are included) and mentions forecasting behavior. However, it does not describe return structure, pagination, or potential side-effects, though the schema's max_records mention helps for the limit aspect.

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 in the first sentence, followed by a concise mention of filtering and forecasting. 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?

Given no output schema, the description offers a hint about return content ('with years worked'). It covers the tool's main purpose and key filtering dimensions (month range, forecasting). It does not enumerate all filter parameters, but the input schema compensates. Overall, it is sufficiently complete for a filtered list tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond what the schema already provides; it merely summarizes month range and selected_year. It does not clarify any additional semantics or edge cases.

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

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

The description clearly states the tool gets upcoming employee work anniversaries for active, non-terminated employees, with years worked. It uses a specific verb and resource, and the active/non-terminated scope distinguishes it from more general tools like list_employees or list_birthdays.

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 usage context: it is for retrieving work anniversaries with month-range filtering and optional future-year forecasting. It does not explicitly name alternatives or when-not-to-use, but the scope is unmistakable and well-aligned with the tool's 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?

The description discloses that search matches first name, last name, or email including email domain, which is useful behavioral context. However, with no annotations, the description does not disclose other behavioral traits such as return format, ordering, or pagination (the latter is only in the schema).

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

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

The description is two sentences, front-loaded with the purpose, and contains no redundant information. It is concise while still conveying the key search behavior.

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, the description covers the core functionality and search behavior. However, it does not mention the optional max_records parameter or any potential defaults/limits, which are only in the schema. Given no output schema, a bit more context about the return value could be useful, but the tool name implies a list.

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%, and the description adds no parameter information beyond what is already in the schema. The schema descriptions for 'search' and 'max_records' are comprehensive, 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 states 'Get recruitment applicants (candidates)' which clearly identifies the resource and distinguishes it from sibling tool 'list_applications' (applications) and 'get_applicant' (single applicant). The verb 'Get' is specific and the resource is well-defined.

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 that this tool searches applicants by first name, last name, or email, which implies when to use it. However, it does not explicitly name alternatives or exclusion criteria, so it stops 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?

With no annotations provided, the description carries the burden of disclosing behavior. It does disclose return contents ('applicant details, stage, source, flags and custom form answers'), but omits any mention of side effects, auth requirements, or pagination behavior. For a read-only list tool, 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?

Two sentences, zero waste. The first sentence states the core functionality and an important limitation; the second lists the return contents. 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 covers the essential context: what the tool does, the key constraint, and what the response includes. With a rich schema and no output schema, it does not need to list every filter parameter. Missing details like pagination are already in the schema, so the description is complete enough for a list operation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the key constraint that job_id is required (by stating 'for a specific job listing'), but this is already encoded in the required array. No additional parameter meaning is provided 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 tool's verb ('Get applications') and resource ('for a specific job listing'), immediately distinguishing it from sibling tools like get_application (single application) and list_applicants. The parenthetical constraint that the API cannot list across all jobs further clarifies its scope.

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

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

The description explicitly scopes usage to a specific job listing and warns that cross-job listing is not supported, providing context for when this tool is appropriate. However, it does not name alternatives like get_application for single applications, so the guidance is not fully explicit.

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

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

No annotations are provided, so the description carries the burden. It states what is returned (identifiers, serial numbers, allocation/return dates, attachments), which is helpful, but it does not disclose pagination, rate limits, permission requirements, or the fact that the API does not paginate (though the max_records parameter description mentions it). It is a benign read operation, but the description adds limited behavioral context beyond the verb 'Get'.

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

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

The description is a single, well-structured sentence that front-loads the action and resource. Every phrase adds value: 'company assets allocated to employees', examples, and the list of returned data. No wasted words.

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

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

Given 11 filter parameters and no output schema, the description is reasonably complete for a simple list tool. It names key return fields and the core resource. It does not describe typical use cases or caveats (e.g., no pagination), but the schema covers filter details adequately. Slightly above minimum but not exhaustive.

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

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

The input schema provides descriptions for all 11 parameters (100% coverage), so the baseline is 3. The description does not add any parameter-level explanation beyond what the schema already provides; it only mentions return fields, not filtering semantics.

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

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

The description clearly states the tool's function: 'Get company assets allocated to employees' with examples (phones, laptops) and specifies the returned data (identifiers, serial numbers, allocation/return dates, attachments). This distinguishes it from sibling tools focused on other entities like contacts, benefits, or projects.

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 employee assets are needed but does not explicitly mention when to use it versus alternatives, nor does it provide any exclusions or comparison with sibling tools. There is no guidance on prerequisites or complementary tools.

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

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

No annotations are provided, so the description must disclose behavioral traits on its own. It correctly implies a read-only operation via 'Get' and lists the returned fields, but it does not clarify whether all attachments are returned when no filters are specified, nor does it mention any access or auth implications. This leaves some ambiguity about default 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, well-structured sentence that front-loads the verb and resource, then lists the key return fields. Every word contributes to the meaning, with no redundancy or filler, making it highly concise and easy to parse.

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

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

Given the tool has 7 optional parameters and no output schema, a more complete description would explain the response structure and the effect of filters, especially the default behavior when no filters are applied. The description lists some return fields (description, download URL, size, module) but omits likely others (e.g., uploaded date, employee code) and does not address default behavior, leaving moderate gaps for an agent.

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

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

The input schema already provides descriptions for all 7 parameters, achieving 100% coverage. The tool's description adds minimal extra meaning beyond the schema—only tying 'description' to '(file name)', which is already noted in the schema. Thus, it meets the baseline for high schema coverage without significant additional value.

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

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

The description clearly states the action ('Get') and the resource ('file attachments stored against employee records'), which distinguishes it from sibling tools like list_employees or list_notes. It also lists the specific fields returned (description/file name, download URL, size, module), leaving no ambiguity about the tool's purpose.

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

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

The description provides clear context by specifying that this tool retrieves attachments associated with employee records. It does not explicitly mention alternatives or when not to use it, but the uniqueness of the 'attachments' resource makes it obvious that this is the tool for that purpose. No exclusions are stated, but the context is sufficiently 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. It indicates a read-only listing operation and lists the attributes returned, but does not disclose behavior such as pagination limits, default result size, or how filters combine. It is not misleading, but the information is sparse beyond the purpose.

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

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

The description is a single, front-loaded sentence that clearly communicates the action and content without fluff. Every word earns its place, earning a 5.

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

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

Given 14 optional parameters and no output schema, the description is quite brief. It does not explain filtering combinations, default limits, or pagination behavior, though the schema covers parameter details. The tool is moderately complex, so a slightly richer description would improve completeness, but it is minimally 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?

Schema coverage is 100% with all 14 parameters having descriptions, so the baseline is 3. The description adds a high-level summary of benefit attributes but does not elaborate on parameter semantics beyond what the schema already provides; thus, it neither helps nor hurts significantly.

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

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

The description clearly states 'Get employee benefit records' with a specific verb and resource, and includes examples of the record contents (health cover, allowances) and fields (type, status, provider, value, dates), which distinguishes it from sibling list tools like list_employees or list_absences.

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

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

The description implies the tool is for retrieving employee benefit records but provides no explicit guidance on when to choose this over other list tools, nor does it mention exclusions or alternatives. The context is clear but not explicitly framed.

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 of behavioral disclosure. It usefully states that only active/non-terminated employees are included and that ages are calculated, and it mentions the optional forecast feature. However, it does not describe the return format, default date horizon, or edge-case behavior when no matches are found.

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 primary purpose, key constraints, and optional capability in under 30 words. There is no redundancy 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?

With 8 optional parameters and no output schema, the description must compensate. It covers the main behaviors and filters, but it omits details about the output structure and default behavior (e.g., what 'upcoming' means and the default month range). This is adequate but has clear gaps.

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

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

Schema description coverage is 100%, and each parameter already has a meaningful description (e.g., selected_year explains forecasting). The tool description adds broad framing about month ranges and future years but does not add significant detail beyond the schema. 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 it retrieves upcoming employee birthdays, restricted to active/non-terminated employees, with calculated age and optional future-year forecasting. The specific verb+resource+scope distinguishes it from sibling tools like list_anniversaries.

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 'upcoming employee birthdays' and 'filter by month range' implies usage for birthday-related queries, and the description makes the tool's content clear. However, it does not explicitly mention alternatives or when not to use this tool, so it stops short of full guidance.

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

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

No annotations are provided, so the description must convey behavioral traits. It correctly implies a read-only operation via 'Get' and mentions return fields (status, progress, dates), which is helpful. However, it omits important context like the client-side max_records limit and lack of server-side pagination (which is only in the schema parameter description). This is a noticeable gap, but the description does not mislead.

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

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

The description is one concise sentence, front-loaded with the core action and resource, and includes relevant examples without any fluff. Every word earns its place, making it highly efficient and easy to scan.

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

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

Given the tool's complexity (9 optional params, no output schema), the description provides a solid overview of what data is returned and the types of checklists involved. It does not fully detail return structure or behavior when no filters are applied, but the explicit mention of status/progress/dates helps an agent understand the tool's scope. With no output schema, a bit more return detail would improve it, but it's adequate for a list tool.

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

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

The schema covers 100% of the parameters with descriptions, so the baseline is 3. The description adds no parameter-specific meaning beyond mentioning assigned/completed dates, which are already described in the schema. It does not clarify filter combinations or special behaviors, but the schema handles parameter documentation adequately.

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

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

The description uses a specific verb ('Get') and identifies the exact resource ('employee checklists') while providing concrete examples (onboarding/offboarding) and key data fields (status, progress percentage, assigned/completed dates). This clearly distinguishes it from sibling tools like list_employees or list_training, making its 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 gives clear context that this tool is for fetching employee checklists with associated metadata, and the name itself reinforces its purpose. It does not explicitly mention when not to use it or name alternatives, but the resource is distinct enough among siblings that no exclusions are necessary. A score of 4 reflects the clear contextual guidance without explicit alternative references.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only describes scope ('contact-centric', 'across multiple employees') but omits details about return structure, default behavior, authentication requirements, or potential side effects. The read-only nature is implied by 'list' but not explicitly stated.

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

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

The description is only two sentences, front-loaded with the core purpose, and contains no filler or redundant details. 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?

Given the tool has 6 filter parameters, no output schema, and no annotations, the description is too sparse to be fully complete. It explains what the tool does but does not mention return format, default limits, or any edge cases. However, the schema descriptions for parameters compensate somewhat.

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 with descriptive parameter definitions, so the baseline is 3. The description adds no additional meaning about parameters, but also does not need to, as the schema fully explains each filter.

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 employee contact records across multiple employees, using a specific verb ('Get') and resource ('contact-centric list'). It also distinguishes itself from the sibling get_employee by noting that individual contacts are included there, clarifying scope.

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

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

The description provides context that this tool is for contact records across multiple employees, and mentions that get_employee also includes individual contacts, hinting at when to prefer that tool. However, it does not explicitly state 'use this when...' or 'do not use when...', so it stops short of a full alternative recommendation.

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 convey behavioral traits. It only restates the resource and fields, adding no information about read-only guarantees, pagination, filtering scope, or permissions. The schema notes the lack of pagination, but the description itself is silent on 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 sentence, front-loaded with the action and resource, with no unnecessary words.

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

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

For a read/list tool with no output schema, the description gives minimal return info (fields included) but leaves behavioral details to the schema. It is adequate for basic understanding but could be more complete regarding result format and limitations.

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

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

All 9 parameters have schema descriptions (100% coverage), so the description adds no extra parameter semantics. The description mentions fields returned but does not elaborate on parameter usage or constraints 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 tool gets dependent/next-of-kin records, listing the fields returned (type, name, contact details, date of birth). It is distinct from sibling tools, none of which specifically target dependents.

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 use for listing dependent records, but provides no explicit guidance on when to use this tool versus alternatives or when not to use it. The context is clear, but no exclusions or alternative tools are mentioned.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It only gives a high-level statement of what is returned and does not mention read-only nature, default behavior when no filters are applied, ordering, pagination, or authentication requirements. This is a significant gap for a tool with no annotation context.

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

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

The description is a single concise sentence that front-loads the verb and resource ('Get employee education history records') and then enumerates included fields. There is no wasted wording 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?

With 12 optional parameters, no output schema, and zero annotations, the description is too minimal. It does not explain default return set, how filters interact, or the structure of the returned records. The high parameter count and lack of output schema require more context to operate effectively.

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

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

All 12 parameters have schema descriptions, covering 100% of parameter semantics. The tool description merely lists some returned fields (institution, qualification, etc.) and does not add any meaning beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states it 'Get employee education history records' and specifies the key fields (institution, qualification, type, status, dates). This distinguishes it from sibling tools like list_employees or list_contacts, which focus on different domains.

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 education history but does not explicitly state when to use it over alternatives or any specific context. No exclusions or alternative tool references are provided, leaving usage inferred from the tool name and description.

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 explains that the operation returns summary details and lists the fields, clarifies that the API does not paginate (via the max_records parameter description), and even notes the API quirk about the 'group' field always being called 'group' internally. These are useful behavioral details that go beyond a simple 'list.' However, it does not explicitly state that this is a read-only and safe operation, though that is strongly implied.

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. The first sentence states the purpose and result type, the second sentence directs to get_employee for deeper detail. It is front-loaded, direct, and contains no filler. Every clause adds value without redundancy.

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

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

The tool has 21 optional parameters and no output schema, so the description must fill gaps. It does by listing the exact summary fields returned and by pointing to get_employee for richer data. It also communicates the non-pagination behavior through max_records, which is crucial for handling potentially large result sets. Yet, it does not specify the default response size or warn about very large result sets when no filters are applied, which would have been helpful given the exploratory nature spotlighted in max_records.

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 100% coverage with each parameter having a descriptive comment. The description itself adds little parameter-level meaning beyond the schema, except that it mentions 'optional filters' generically and the max_records note is also in the schema. Given the high schema coverage, a baseline score of 3 is appropriate; the description does not need to compensate.

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

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

The description opens with a specific verb-resource pair: 'Get a list of employees in HR Partner,' immediately clarifying the tool's function. It further distinguishes from the sibling 'get_employee' by noting that this returns summary details, and it lists the summary fields, which clearly separates this list endpoint from more detailed retrieval tools.

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

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

The description provides clear directional guidance: for full details including contacts, addresses, and custom fields, it directs users to 'get_employee' with the employee code. It implies that this tool is for browsing or searching with optional filters, but does not explicitly enumerate scenarios where this tool should not be used (e.g., when needing specific contact or address data). This is a minor gap given the sibling list tools, but the main alternative is addressed.

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 response shape depends on report_type, which is a key behavioral trait. It doesn't mention pagination or default return size, but the schema's max_records description already covers the no-pagination behavior, so the description adds value beyond 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?

Two concise sentences, first stating purpose, second explaining the key parameter. No wasted words.

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

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

Given the tool has 15 parameters and no output schema, the description does not summarize the filter capabilities, but the schema provides comprehensive parameter descriptions. The description's focus on report_type gives essential clarity for the required parameter, making it adequate for the complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no new parameter semantics beyond restating the report_type enum values, which are already fully described in the schema.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('employee expense claims'), distinguishing it from sibling list_* tools by focusing on the expense domain. It additionally explains the three report_type shapes, which clarifies the tool's scope.

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

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

The description provides clear context for choosing a report_type, explaining what each variant returns. It doesn't name any alternative tools for expense claims, but since no expense-specific sibling exists, this is sufficient context without explicit exclusions.

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

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

With no annotations provided, the description must carry the transparency burden. 'Get' indicates a read operation, and it specifies what data is returned. However, it does not disclose behavior such as pagination (max_records parameter), default filtering scope, or whether all goals are returned by default. The description is accurate but lacks behavioral depth.

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

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

The description is a single sentence that is front-loaded with the action and resource, and every word adds value. It avoids redundancy and is appropriately sized for the tool's simplicity.

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?

There is no output schema, so the description reasonably explains return values by listing the fields. Given the tool's moderate complexity (14 filter parameters), the description is sufficient for a list operation, though it could mention that filtering is supported. It does not need to repeat schema details, and it gives enough context for an agent to understand the tool's purpose.

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

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

Schema description coverage is 100%, so the baseline is 3. The description provides a high-level summary of the data fields (scope, type, target/current values, completion, due dates) but does not add semantic meaning beyond what the schema already documents. It does not elaborate on filter usage or parameter interactions.

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 ('company and employee goals') and lists the key attributes returned (scope, type, target/current values, completion and due dates). This distinguishes it from sibling tools like list_employees or list_absences, 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 implies usage by resource type but does not explicitly state when to use this tool versus alternatives or provide exclusions. Among the many list_* siblings, list_goals is the only one for goals, so context makes it clear, but there is no direct 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, the description must carry the transparency burden; it conveys a read-only listing behavior but does not disclose potential limitations such as how filters combine, default return size, or any side effects. It adequately states that records include the listed fields, but lacks depth.

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

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

The description is a single concise sentence, front-loaded with the action and resource, with no redundant words. 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, combined with the fully-described schema, gives a basic understanding of the tool's purpose and filters. However, it omits information about default behavior (e.g., returns all grievances when no filters are applied) and does not describe the output structure beyond a few fields, so it is not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description lists several response fields that correspond to filter parameters but adds no meaning beyond the schema's own per-parameter 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 uses the specific verb 'Get' and clearly identifies the resource as 'employee grievance / complaint / harassment records', which distinguishes this tool from sibling list tools. It also enumerates key fields, making its purpose unmistakable.

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

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

No usage guidance is provided. The description does not mention when to use this tool vs alternatives, nor any exclusions or prerequisites, leaving the agent to infer based solely on the tool 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 the full burden. It implies a read-only operation and lists return fields, but does not disclose default behavior (e.g., unbounded results), filtering specifics, or any side effects. This is adequate but shallow for a tool with no annotations.

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

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

The description is a single sentence that front-loads the purpose ('Get employee interview / meeting records') and lists key output fields. Every word earns its place 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 8 optional filters and no output schema, yet the description provides only minimal return-field info and no mention of output structure, filter interaction, or default behavior. While the schema covers parameters, the description leaves several 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?

Schema coverage is 100% with each of the 8 parameters described. The description adds no new parameter-level meaning beyond mentioning the fields that appear in records (type, interviewer, description, dates), so the baseline score 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 retrieves employee interview/meeting records and specifies the included fields (type, interviewer, description, dates). This distinguishes it from sibling list_* tools for other entity types like employees, contacts, or absences.

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

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

The description gives no guidance on when to use this tool vs. alternatives. It simply states what it returns without suggesting scenarios, exclusions, or comparisons to other list tools, leaving usage entirely implied.

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 outlines the response fields and points to get_job for deeper detail, but it does not disclose any potential side effects, pagination behavior, or rate limits. Since this is a simple read/list operation, the lack of additional caution is acceptable 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 sentences, front-loading the main action and then pointing to an alternative. Every phrase adds value; there is no redundancy or 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?

For a list tool with 16 parameters and no output schema, the description covers the core purpose, mentions the return fields, and names the natural next step (get_job). It could note that filters are optional or that all jobs are returned if no filters are given, but the schema already implies this. Overall, it provides enough context for an agent to use the tool effectively.

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

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

Schema coverage is 100% with each parameter described in detail, so the baseline is 3. The description does not add additional parameter semantics beyond the schema; it only names the return fields. It doesn't clarify relationships like whether filters are cumulative, but that's not required given the schema's thoroughness.

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 recruitment job listings with title, department, location, position, publish dates and flags.' It names specific fields and explicitly contrasts with get_job, which is used 'for full detail,' distinguishing list_jobs from its sibling.

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 direct usage guidance by stating, 'Use get_job with the job id/slug for full detail including application form, scorecard and pipeline stages.' This clearly tells the agent when to use an alternative tool, implying list_jobs is for quick, summarized listings.

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

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

There are no annotations, so the description carries the full burden. It discloses a significant performance trait ('balances are slow to compute') and implies read-only behavior through 'Get.' It also indicates the returned content, though it does not detail auth or side effects (which are not relevant for a read-only 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?

Two sentences with zero fluff: the first defines the tool's scope, the second delivers crucial performance guidance. Every word contributes. It is appropriately front-loaded and easy to parse.

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

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

Given the tool's complexity (9 optional params, no output schema), the description adequately conveys what the tool returns and warns about computational cost. It doesn't explain pagination, but the max_records parameter description covers that. The enumeration of output fields compensates for 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 coverage is 100%, so the parameters are already well documented. The description references 'employee' and 'policy' as filter examples, aligning with the employee and absence_reason parameters, but adds no additional meaning beyond what the parameter descriptions already provide.

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: 'employee leave balances per leave policy.' It enumerates the data fields (entitlement, current balance, carryover, units, accrual details), which distinguishes it from sibling tools like list_absences and list_leave_requests.

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 explicit usage guidance: 'always filter to the smallest dataset needed' with concrete examples (single employee or policy). It does not explicitly name alternatives or state when not to use this tool, but provides strong contextual guidance for effective invocation.

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 the returned fields and implies a limitation (no full approval detail) via the second sentence. However, it does not mention read-only behavior, pagination, or response structure beyond the schema, leaving some behavioral aspects implicit.

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

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

The description is two concise sentences with no filler. It front-loads the main purpose and then gives a helpful pointer to an alternative. 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?

The tool has 14 parameters and no output schema, so the description could do more to summarize the tool's capabilities and return shape. It lists a few output fields but fails to mention that it supports broad filtering (employee, department, location, date ranges, etc.) and that max_records enforces a client-side limit. The schema covers these, but the description leaves the overall context somewhat incomplete for an agent deciding whether to use this tool.

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

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

Schema description coverage is 100%, so the schema already documents all 14 parameters in detail. The description mentions some concepts (status, absence reason, dates, description) but does not add meaning beyond the schema. Thus, the baseline score of 3 applies as the description provides no extra parameter clarification.

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: 'Get employee leave (time off) requests' and lists key output fields. It also distinguishes itself from the sibling get_leave_request by noting that the latter provides 'full approval detail on one request', which clarifies the scope of this 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?

The description explicitly mentions an alternative: 'Use get_leave_request for full approval detail on one request.' This provides a clear when-not/alternative hint, and the list-oriented purpose is evident from the name and the description, making usage guidance effectively explicit.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It mentions return fields and optional event history but does not describe filtering behavior, default scope, or any side effects. The read-only nature is implied by 'Get' but not explicitly revealed.

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

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

The description is a single concise sentence, front-loaded with the core purpose. It contains no redundant or irrelevant information, making it efficient for an agent to parse.

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

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

Given the tool's complexity (10 parameters, no output schema, no annotations), the description is too brief. It does not mention filtering capabilities, default behavior, or return structure beyond a few fields. An agent would need to inspect the schema to understand the tool's full capabilities, which the description should help contextualize.

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

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

The schema provides 100% coverage with descriptions for all 10 parameters. The description adds minimal extra meaning, referencing hashtags and event history which correspond to 'tags' and 'include_events', but this is duplicative of the schema. 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 the specific verb 'Get' with the resource 'employee notes' and lists key content fields. This clearly distinguishes it from sibling list tools like list_employees or list_contacts.

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, nor any exclusions or prerequisites. The description only states what the tool does, not the context in which it should be selected.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses that include_answers/form_data can significantly increase response time and advises combining with filters, which is a meaningful non-obvious trait. It does not detail security/permissions, but as a read operation, the performance warning adds substantial transparency.

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

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

Two sentences, front-loaded with purpose, no fluff. Effectively communicates core function and key caveat in minimal space.

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 15 parameters and no output schema, the description provides a solid overview of the returned data (status, template, dates) and flags performance considerations. It leaves detailed parameter behavior to the schema, which is complete, so it is adequately complete for a tool of this complexity.

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

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

Schema coverage is 100% with descriptions for all 15 parameters, meeting the baseline. The description's mention of slow response for answers is already present in the schema's include_answers field, so it adds no new parameter semantics 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?

Description clearly states it retrieves performance review cycles with status, template, and date fields, using a specific verb 'Get' and resource. However, it does not explicitly distinguish itself from the sibling tool 'list_reviews', which could be similar, so it stops short of full differentiation.

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

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

Provides usage context by warning that including answers significantly increases response time and recommends combining with filters, which guides effective use. However, it does not state when to choose this tool over alternatives like list_reviews, nor does it mention exclusions or conditions.

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

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

No annotations are provided, so the description must carry the full burden of disclosing behavioral traits. The description is limited to a single sentence stating the content of records; it does not mention that this is a read-only operation, any required permissions, pagination behavior (although the schema mentions max_records, that's not part of the description), or potential side effects. The verb 'Get' hints at read-only, but this is insufficient for full transparency.

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

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

The description is a single, succinct sentence that immediately conveys the tool's purpose. No filler or redundant content; every word contributes to clarity. It is appropriately front-loaded with the action and object.

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 12 parameters and no output schema, the description gives a reasonable overview of the tool's purpose and the type of data returned, but it lacks details about the response structure (e.g., whether it returns a list, any default limits) and does not summarize the filtering capabilities. The schema covers parameter details, so the description is adequate but not fully complete for an agent to anticipate behavior confidently.

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 some context by listing key fields (position name, remuneration, pay level, dates) that correspond to several parameters, but it does not add new meaning beyond the schema's explicit parameter descriptions. It neither clarifies parameter formats nor introduces any additional semantics.

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

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

The description states a specific verb ('Get') and a clear resource ('employee position (job) history records'), and it lists the included fields (position name, remuneration, pay level, commence/completion dates). This clearly distinguishes it from sibling tools like list_jobs or get_job, which likely address different job-related data.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., list_jobs, get_employee). There is no mention of prerequisites, exclusions, or cases where another tool would be more appropriate. It only states what the tool does, implying use when position history is needed, but without explicit 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 disclosure burden. The verb 'Get' implies a read-only operation, and it mentions the data sources and returned fields. However, it does not explicitly state safety (e.g., no side effects), rate limits, or pagination behavior, leaving some behavioral details implicit.

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

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

The description is a single, concise sentence that starts with the primary action and resource, then lists relevant data fields. Every phrase adds value, and there is no redundancy or wasted 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?

Despite having no output schema and no annotations, the description covers what the tool does, the data sources, and the fields returned. The schema handles parameter documentation, including the non-paginating API behavior via max_records. Missing details like response structure or ordering are minor for a list operation.

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

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

Schema description coverage is 100%, so the parameter descriptions fully document each filter. The tool description adds no extra meaning beyond the schema, which is acceptable given the schema works well alone.

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 ('project/activity costing entries'), with an explicit note that these come from timesheets and expenses. It also lists the key data fields, distinguishing itself from sibling tools like list_timesheets or list_expenses.

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 conveys the context of use by indicating that this returns consolidated costing entries from timesheets and expenses. It does not explicitly mention when not to use it or name alternatives, but the clear scope is sufficient for distinguishing it from 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?

There are no annotations provided, so the description carries the full burden for behavioral disclosure. The description only states the output fields and does not mention that this is a read-only list operation, that it returns multiple records, or that filtering is available. It also fails to disclose any limitations like pagination (though max_records param hints at it). This is a significant gap for a list tool.

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

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

The description is a single, tightly worded sentence with no filler. It front-loads the resource ('admin reminders') and then lists the key attributes returned. It is appropriately concise for the information it conveys.

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

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

With no annotations and no output schema, the description should more thoroughly explain the tool's behavior. It does not mention that it returns a list, that filters are available, or how it differs from get_reminder. For a tool with 8 optional parameters and sibling tools, this description is under-specified.

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

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

The input schema has 100% description coverage for all 8 parameters, so the schema already explains each filter. The description adds minimal value by naming some output fields, but it does not clarify that all parameters are optional filters or provide any additional context beyond the schema. 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 lists admin reminders and specifies key attributes returned (description, module, remind date, notification flags, responsible user/employee). The verb 'Get' is specific, and the plural 'reminders' distinguishes it from sibling tools like get_reminder which retrieves a single record.

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 statement of what the tool does, implying it is for fetching a list of reminders. However, it does not explicitly mention when to use this vs. alternatives such as get_reminder for a single reminder, nor does it note any prerequisites or exclusions. Usage is inferred from the name and description but not explicitly guided.

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

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

No annotations are present, so the description must convey behavioral traits. While 'Get' implies read-only, the description doesn't disclose filter capabilities, default result limits, pagination behavior, or potential performance implications.

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, front-loaded sentence with no filler. It efficiently communicates purpose and examples while remaining concise.

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

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

With 10 parameters, no annotations, and no output schema, the description is too sparse. It doesn't explain filtering options, default behavior (e.g., returns all records), or any usage constraints, leaving the agent to rely on the schema for operational 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 schema provides 100% parameter descriptions, so the baseline is 3. The description itself doesn't add parameter-level detail but lists output fields, which is helpful. No deduction 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 retrieves employee renewable document records (licences, certifications, visas) and lists key fields (type, description, issue date, renewal due date). This distinguishes it from sibling list tools by specifying the exact record type and scope.

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

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

No guidance is provided about when to use this tool versus other list tools. It doesn't mention alternatives, prerequisites, or scenarios where this tool is preferred or not.

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 exist, so the description carries the full burden. It discloses the returned fields (type, status, reviewer, score, review dates) and implies that full performance review forms are not included. However, it does not describe output format or pagination behavior, though the schema's max_records parameter already notes the API does not paginate. For a read-only listing tool, this is solid but not exhaustive.

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

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

Two short, front-loaded sentences. The first states the action and scope, the second gives a cross-reference to a sibling tool. No wasted words.

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

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

With 12 optional parameters and no output schema, the description provides the core context: what records are returned and which tool to use for full forms. It does not describe the exact response structure, but the schema covers parameter details. It is nearly complete for a listing tool, though it could mention the response shape 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?

Schema description coverage is 100% and every parameter is well-documented in the input schema. The tool description adds no new parameter-level meaning; it only lists fields that appear in the output. Baseline 3 is appropriate because the schema already handles parameter semantics.

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

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

The description uses a specific verb 'Get' and resource 'employee review records' with examples (probation reviews, performance check-ins). It explicitly directs users to list_performances for full performance review forms, clearly distinguishing this tool's scope.

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

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

The description gives explicit guidance: it states what reviews are included and tells the agent to see list_performances for full performance review forms. This is an explicit alternative named, so the agent knows when to use this tool vs the sibling.

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 that records are retrieved, but does not disclose whether filtering is supported, whether pagination occurs, or any permissions are needed. The schema hints at filtering, but the description does not confirm or explain these behaviors, leaving the agent uncertain about how the tool will behave.

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

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

The description is a single sentence of 10 words, front-loaded with the core purpose. It contains no filler or redundant information, making it highly concise while still conveying the essential action and resource.

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

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

Given the tool's moderate complexity (8 optional parameters, no output schema, no annotations), the description is minimal but adequate. It tells the agent what data is returned, but does not mention that the tool supports filtering or that it returns a list (though 'records' implies plural). The parameter schema covers the filtering options, so the description does not need to repeat them, but it could be more complete by stating that records can be filtered and that multiple records may be returned.

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

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

Schema description coverage is 100%, so the input schema already fully documents all 8 parameters. The description adds no additional parameter semantics; it only mentions output fields (skill name, rating, comments), which are not parameter descriptions. Thus the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Get employee skill records including skill name, rating and comments.' The verb 'Get' and resource 'employee skill records' are specific, and the mention of fields (skill name, rating, comments) distinguishes it from other list tools in the sibling set, which focus on different domains (absences, assets, benefits, etc.).

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or suggest sibling tools for related queries (e.g., employee details). Usage is only implied by the tool's name and description, which is insufficient given the large sibling set.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It transparently warns about the risk of large data volumes and timeouts, which is critical behavioral context. It also explains that data is returned grouped by template, sequence, employee, and entries. It does not mention whether the operation is read-only, but 'Get' implies this, and the warning about data volume adds significant transparency.

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

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

The description is two sentences: the first states the purpose, the second is a concise warning. It is front-loaded, contains no redundant information, and every sentence earns its place. This is exemplary conciseness.

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

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

Given the tool's complexity (16 optional parameters, no annotations, no output schema), the description provides essential context: it warns about large data and recommends filters, and it hints at the response structure via grouping. It does not fully describe return formatting, but the schema covers parameters, and the warning addresses a key usage pitfall. Overall, it is reasonably complete for a list tool.

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

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

Schema coverage is 100%, meaning every parameter has a description in the schema itself. The tool description adds no additional specifics about parameter semantics, only reinforcing the general advice to use date or employee filters. Per the rubric, a baseline of 3 is appropriate when the schema fully documents parameters and the description does not add extra meaning.

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

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

The description clearly states the tool's function: 'Get timesheet data grouped by timesheet template, sequence (period), employee and individual time entries.' This specifies the verb (Get), the resource (timesheet data), and the grouping dimensions, which also distinguishes it from the sibling tool 'get_timesheet' that likely returns a single timesheet.

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 includes practical usage guidance: 'Warning: can return a LOT of data; always use date ranges or employee filters to avoid timeouts.' This advises when to apply filters and highlights performance considerations. However, it does not explicitly compare with alternatives like 'get_timesheet' for single-record needs, so it falls short of full when-to-use vs alternatives 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, the description carries the full burden. 'Get' implies a read-only operation, and the description accurately lists the data returned. However, it does not explicitly state that it is read-only, nor does it mention any limitations, performance implications, or behavior when no filters are provided. It is not misleading, but it adds minimal behavioral context beyond the action itself.

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

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

The description is a single sentence that conveys the essential purpose and fields. It is efficient and front-loaded with the verb and resource. The list of fields is slightly long, but it remains clear and does not waste words.

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

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

Given the tool's complexity (16 parameters, no output schema, no annotations) and the presence of overlapping sibling tools, the description is too sparse. It does not mention that all filters are optional, how to combine them, what a typical response looks like, or any caveats such as the client-side max_records limit. It also fails to differentiate from similar list tools, leaving the agent without enough context to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description lists fields that map directly to the schema parameters (type, status, course name, institution, cost, reimbursement, dates) but does not add any extra meaning, such as filter combination behavior or default values. It simply echoes the parameter names without enhancing understanding.

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

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

The description clearly identifies the action ('Get') and the resource ('employee training course records'), and lists the key fields (type, status, course name, institution, cost, reimbursement, dates). This is specific enough to distinguish it from sibling tools like list_education and list_skills.

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, no exclusions, and no prerequisites. The description simply states what it does without contextualizing when it should be chosen over similar list tools such as list_education or list_skills.

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 behavioral disclosure. It discloses upsert behavior (keyed by email), the ability to link job applications, and the prerequisite that stage names must already exist. It does not mention permissions, return values, or whether existing job_applications are replaced, but the disclosed details are meaningful.

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

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

The description is two sentences, front-loaded with the core action, and every clause earns its place. It avoids fluff and clearly packs the upsert mechanism, job-linking ability, and stage prerequisite without redundancy.

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

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

Given the moderate complexity (4 parameters, including a nested array) and lack of an output schema, the description covers the essential behavior: creating/updating, linking to jobs, and stage validation. It leaves minor ambiguity about whether job_applications replaces or appends and what the return value is, but overall it provides sufficient context for an agent to select and invoke the tool.

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

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

The schema covers 100% of parameters with detailed descriptions, including the unique-identifier role of email and the stage-name prerequisite. The description adds a helpful summary of linking semantics but mostly restates schema information, so it doesn't significantly elevate understanding 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 tool creates or updates an applicant (upsert by email), and explains it can link applicants to jobs and pipeline stages. It uses a specific verb+resource combination and distinguishes itself from siblings like save_application by focusing on the applicant entity.

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 creating a new applicant or updating an existing one via email. It implicitly contrasts with read-only sibling tools like get_applicant, though it doesn't name alternatives explicitly or provide exclusions for cases like deleting.

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, and it does so well. It reveals important side effects: the tool upserts the applicant by email, falls back to a company default stage on invalid stage names, and keys custom form answers by field names from the job listing. It does not discuss return values or authentication requirements, but the disclosed edge cases are valuable.

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 three sentences that are efficient and front-loaded. The first sentence states the core action, the second adds a key side effect and edge-case behavior, and the third clarifies how a parameter should be used. No information is redundant with the schema, 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?

Given the tool's complexity — 7 parameters, a nested object, no output schema, and no annotations — the description covers the essential behaviors and edge cases well. It explains the upsert side effect, stage fallback, and custom form keying, but it does not describe the response shape or any prerequisites. This is adequate for invocation, but not exhaustive.

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

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

Since the schema already describes all 7 parameters at 100% coverage, the baseline is 3. The description adds meaningful semantics beyond the schema by explaining how custom_form_answers map to get_job fields and how stage_name handling falls back to a default. This elevates the parameter guidance above what structured data alone offers.

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 'Create a new job application or update an existing one,' giving a specific verb and resource that clearly differentiates from sibling tools like save_applicant or get_application. It further clarifies scope by noting it also upserts the applicant by email, leaving no ambiguity about what this tool does.

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

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

The description clearly implies when to use the tool — when creating or updating a job application — but does not explicitly contrast it with the sibling save_applicant or explain when to prefer one over the other. It does hint at related workflow via 'see get_job' for custom form answers, but there are no explicit exclusions or alternative tool references.

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