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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool adds an entry, implying a write operation, but doesn't cover permissions, side effects, error handling, or response format. The mention of 'works with modern template' adds some context but is insufficient for a mutation tool.

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

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

The description is front-loaded with the core purpose, followed by a structured parameter list. Each sentence earns its place by clarifying parameters, though the 'works with modern template' clause could be more integrated. Overall efficient with minimal waste.

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 a mutation tool with no annotations, 6 parameters, and an output schema (which reduces need to describe returns), the description is moderately complete. It covers parameter semantics well but lacks behavioral details like error conditions or template compatibility specifics, leaving gaps for safe usage.

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

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

Schema description coverage is 0%, so the description must compensate. It provides meaningful explanations for all parameters (e.g., 'School/University name' for institution, 'Degree and major' for degree), including optionality notes for location and details. This adds substantial value beyond the bare 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 ('Add a new education entry') and target resource ('to a resume'), with specific context about working with modern templates. It distinguishes from siblings like 'add_experience' by focusing on education rather than work experience, though it doesn't explicitly contrast them.

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 adding education to a resume, particularly with modern templates, but doesn't explicitly state when to use this versus alternatives like 'edit_resume' or 'create_resume' for similar modifications. No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool adds entries, implying a write/mutation operation, but doesn't disclose critical behavioral traits such as whether it overwrites existing experiences, requires specific file formats or permissions, handles errors (e.g., invalid filenames), or what happens on success/failure. The mention of 'works with modern template' hints at compatibility but lacks detail.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by a structured Args section that efficiently lists parameters with brief explanations. Every sentence earns its place, with no redundant or verbose content.

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

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

Given the tool has an output schema (which likely covers return values), the description is moderately complete. It explains the purpose and parameters well but lacks behavioral context (e.g., mutation effects, error handling) and usage guidance relative to siblings. For a write operation with no annotations, more disclosure on side effects or constraints would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for all parameters: filename (resume file name), company (company name), title (job title), dates (employment dates with format example), bullets (list of bullet points), and location (optional city/state/country). This adds substantial meaning beyond the bare schema, though it could benefit from more detail on filename constraints or bullet formatting.

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

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

The description clearly states the specific action ('Add a new work experience entry') and resource ('to a resume'), distinguishing it from siblings like add_education (which adds education entries) or edit_resume (which modifies existing content). It specifies it works with modern templates, providing additional context about compatibility.

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 specifying it adds work experience entries to resumes, suggesting it should be used when creating or updating a resume with employment history. However, it doesn't explicitly state when to use this tool versus alternatives like edit_resume for modifying existing experiences or create_resume for initial setup, nor does it mention any prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's behavior (compilation to PDF, returns path or errors), but lacks details on permissions, rate limits, or side effects. It adequately describes the core operation without contradictions, but could be more comprehensive for a tool with no annotation support.

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

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

The description is front-loaded with the core purpose, followed by concise parameter explanations and return value details. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.

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 (2 parameters, no annotations, but with an output schema), the description is fairly complete. It covers the purpose, parameters, and returns, but could improve by addressing potential errors or dependencies. The output schema likely handles return values, so the description's focus on path or errors is sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining 'filename' as the resume file to compile and 'output_dir' as the output directory with a default, which clarifies beyond the schema's basic titles. However, it doesn't detail file format requirements or path constraints, leaving some gaps.

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

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

The description clearly states the specific action ('Compile a LaTeX resume to PDF using pdflatex'), identifies the resource ('resume file'), and distinguishes it from siblings like create_resume, edit_resume, and read_resume by focusing on compilation rather than creation, editing, or reading.

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 compiling LaTeX resumes to PDF, but it does not explicitly state when to use this tool versus alternatives like create_resume or edit_resume, nor does it provide exclusions or prerequisites. The context is clear but lacks explicit guidance on 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 provided, the description carries the full burden of behavioral disclosure. It mentions file creation and template options, but does not cover critical aspects like permissions needed, whether the operation is idempotent, error handling, or file system impacts. This leaves significant gaps for a mutation tool.

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

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

The description is appropriately sized and front-loaded with the main purpose. The Args and Returns sections are structured clearly, though the 'Returns' statement is somewhat redundant given the output schema. Every sentence adds value, but minor trimming could improve efficiency.

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 (3 parameters, mutation operation) and the presence of an output schema, the description is moderately complete. It covers parameter semantics well but lacks behavioral details like error cases or side effects. The output schema reduces the need to explain return values, but more context on tool behavior would enhance completeness.

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

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

The description adds meaningful semantics beyond the input schema, which has 0% description coverage. It explains that filename can include or exclude .tex extension, content is full LaTeX content with a fallback to template, and lists template options. This compensates well for the schema's lack of descriptions.

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

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

The description clearly states the specific action ('Create a new LaTeX resume file') with the resource ('resume file'), distinguishing it from siblings like edit_resume or delete_resume. It specifies the file format (LaTeX) and the output type, making the purpose unambiguous.

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

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

The description implies usage through parameter explanations (e.g., content vs. template), but does not explicitly state when to use this tool versus alternatives like edit_resume or compile_resume. It provides some context for parameter choices but lacks explicit guidance on tool selection among siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes a file, implying a destructive mutation, but doesn't specify if deletion is permanent, requires confirmation, affects other data, or has permission requirements. This is a significant gap for a destructive operation with zero annotation coverage.

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

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

The description is extremely concise and well-structured: a clear purpose statement followed by a brief parameter explanation. Every sentence earns its place, with no redundant or vague language, making it easy to parse quickly.

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

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

Given the tool's destructive nature, no annotations, and an output schema (which might cover return values), the description is minimally adequate. It states what the tool does and the parameter, but lacks critical behavioral details like safety warnings or error handling. The presence of an output schema prevents a lower score, but more context is needed for a destructive 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 description adds meaningful context for the single parameter 'filename' by specifying it as 'Name of the resume file to delete', which clarifies its role beyond the schema's basic title 'Filename'. With 0% schema description coverage and only one parameter, this compensates adequately, though it doesn't detail format constraints (e.g., file extensions).

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

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

The description clearly states the action ('Delete') and resource ('a LaTeX resume file'), making the purpose immediately understandable. It distinguishes itself from siblings like 'create_resume', 'edit_resume', and 'read_resume' by specifying deletion. However, it doesn't explicitly contrast with 'list_resumes' or other file operations, keeping it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., the file must exist), exclusions (e.g., cannot delete non-existent files), or related tools like 'list_resumes' for checking available files. This lack of context leaves the agent to infer usage scenarios.

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

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

No annotations are provided, so the description carries the full burden. It discloses that editing replaces content ('replaces everything') and offers two behavioral modes (full vs. targeted replacement). However, it lacks details on permissions, error handling (e.g., if file doesn't exist), side effects, or response format. For a mutation tool with zero annotation coverage, this is a moderate gap.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose, followed by a bullet-like list of args with explanations, and ends with a clear usage rule. Every sentence earns its place with no wasted words, 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?

Given the tool's complexity (mutation with 4 parameters), no annotations, and an output schema (which reduces need to describe returns), the description is fairly complete. It covers purpose, parameters, and usage modes. However, as a mutation tool, it could benefit from more behavioral context (e.g., error cases, idempotency) to fully compensate for the lack of annotations.

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 0%, so the description must compensate. It adds significant meaning: it explains that 'filename' is the file to edit, 'content' is for full replacement, and 'find'/'replace' work together for targeted edits. It clarifies the mutual exclusivity of the two modes. This goes well beyond the schema's basic titles, though it doesn't detail formats (e.g., LaTeX syntax).

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: 'Edit an existing LaTeX resume file.' It specifies the verb ('edit') and resource ('LaTeX resume file'), making it immediately understandable. However, it doesn't explicitly differentiate from siblings like 'create_resume' or 'read_resume' beyond the 'existing' qualifier, which is implied but not stated as a distinction.

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 guidance on when to use this tool: 'Either provide 'content' for full replacement, or 'find' and 'replace' for targeted edit.' This explains the two usage modes. It doesn't explicitly state when not to use it (e.g., vs. 'create_resume' for new files or 'add_education' for incremental updates), but the context is clear enough for basic decision-making.

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 this is a 'Get' operation, implying read-only behavior, but doesn't specify whether it requires permissions, has side effects, returns structured data, or handles errors. For a configuration tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and includes specific details about what's retrieved. Every element earns its place without redundancy or unnecessary elaboration.

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

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

Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is reasonably complete. It specifies what configuration data is retrieved, which addresses the core purpose. However, without annotations and with behavioral gaps, it could benefit from more context about usage patterns or return format, though the output schema mitigates some of this.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description adds value by specifying what configuration information is retrieved ('directories and pdflatex status'), which goes beyond the empty schema. This compensates appropriately for the parameter-less design.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('current configuration'), including what information is retrieved ('directories and pdflatex status'). It distinguishes from siblings like 'get_template' or 'read_resume' by focusing on system configuration rather than resume data. However, it doesn't explicitly differentiate from all siblings in the description text itself.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, appropriate contexts, or exclusions. Given the sibling tools are all resume-related operations, the implicit context might be checking system configuration before resume operations, but this is not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns LaTeX content, which is useful, but lacks details on permissions, error handling, or rate limits. For a read operation with no annotations, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is front-loaded with the core purpose, followed by clear sections for arguments and returns. Every sentence adds value without redundancy, making it efficient and easy to parse for an agent.

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 an output schema (which likely describes the return structure), the description doesn't need to detail return values. However, with no annotations and incomplete parameter guidance (e.g., no full enum list), it's adequate but leaves gaps in behavioral context and usage compared to siblings.

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

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

The description adds meaningful context for the single parameter 'template_name' by listing example values (modern, classic, minimal), which the schema does not provide (0% coverage). This compensates well for the lack of schema descriptions, though it doesn't specify if these are the only valid options or just examples.

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 the content of a resume template.' It specifies the verb ('Get') and resource ('resume template'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'list_templates' or 'read_resume', which might retrieve different types of content.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_templates' (which might list template names) or 'read_resume' (which might retrieve resume data), leaving the agent without context 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 provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: listing files, specifying the directory ('resumes directory'), and detailing the return format ('filename, last modified date, and file size'). However, it omits details like pagination, error handling, or file format constraints, which would be useful for a read operation.

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

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

The description is two concise sentences with zero waste: the first states the action and resource, and the second specifies the return values. It is front-loaded with the core purpose and efficiently structured, making it easy to parse without extraneous details.

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

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

Given the tool's low complexity (0 parameters, read-only operation), an output schema exists, and the description covers the purpose, scope, and return format adequately. It lacks some behavioral context like error cases or directory specifics, but for a simple list tool, it is mostly complete and functional.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately adds no parameter details, avoiding redundancy. A baseline of 4 is applied as it correctly handles the zero-parameter case without unnecessary information.

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

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

The description clearly states the specific action ('List all LaTeX resume files'), resource ('in the resumes directory'), and scope ('all'). It distinguishes from siblings like 'list_templates' (which lists templates) and 'read_resume' (which reads a specific resume), making the purpose unambiguous and well-differentiated.

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

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

The description implies usage for retrieving resume metadata, but provides no explicit guidance on when to use this tool versus alternatives like 'read_resume' (for content) or 'list_templates' (for templates). It lacks when-not-to-use scenarios or prerequisites, leaving usage context inferred rather than stated.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns 'names and descriptions,' which adds useful context about output format. However, it lacks details on behavioral traits such as pagination, rate limits, or error conditions, which are important for a list operation.

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

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

The description is two sentences with zero waste: the first states the purpose, and the second specifies the return content and resource type. It is front-loaded and appropriately sized, with every sentence earning its place by adding essential 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?

Given the tool's low complexity (0 parameters, output schema exists), the description is mostly complete. It covers purpose and output semantics adequately. However, it could improve by mentioning any limitations (e.g., only built-in templates) or prerequisites, which would enhance completeness for the agent.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by clarifying the resource scope ('built-in LaTeX resume templates'), which goes beyond the schema. This compensates well for the lack of parameters, earning a score above the baseline of 3.

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

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

The description clearly states the specific action ('List available resume templates') and resource ('built-in LaTeX resume templates'), distinguishing it from siblings like 'get_template' (which retrieves a specific template) or 'list_resumes' (which lists created resumes). It precisely communicates what the tool does without redundancy.

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

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

The description implies usage context by specifying 'built-in LaTeX resume templates,' suggesting this tool is for browsing available templates rather than user-created ones. However, it does not explicitly state when to use it versus alternatives like 'get_template' or provide exclusions, leaving some ambiguity for the agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions reading file contents and returning LaTeX data, but does not specify error handling (e.g., if the file doesn't exist), permissions required, or performance characteristics like rate limits. This leaves gaps in understanding the tool's behavior.

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

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

The description is front-loaded with the core purpose, followed by concise sections for arguments and returns. Every sentence adds value without redundancy, making it easy to scan and understand quickly. The structure is efficient and waste-free.

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

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

Given the tool's low complexity (one parameter) and the presence of an output schema (which handles return values), the description is largely complete. It covers the purpose, parameter semantics, and return type adequately. However, it could improve by addressing behavioral aspects like error cases, given the lack of annotations.

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

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

The schema has 0% description coverage, but the description compensates by explaining the 'filename' parameter's semantics: it accepts names with or without the .tex extension. This adds meaningful context beyond the schema's basic type definition, though it doesn't detail constraints like valid filename formats.

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

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

The description clearly states the specific action ('Read the contents') and resource ('a LaTeX resume file'), distinguishing it from sibling tools like 'list_resumes' (which enumerates files) or 'compile_resume' (which processes the file). It precisely defines the tool's function without ambiguity.

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

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

The description implies usage for retrieving LaTeX content from a resume file, but does not explicitly state when to use this tool versus alternatives like 'list_resumes' (to find filenames) or 'edit_resume' (to modify content). It provides basic context but lacks explicit guidance on exclusions or prerequisites.

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