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

Annotations indicate this is a non-readOnly, non-destructive, openWorld operation. The description adds minimal context by implying admin-level access but doesn't elaborate on behavioral traits like authentication needs, error handling, or what 'Add' entails (e.g., creates new record). It doesn't contradict annotations, so it's adequate given the structured data.

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

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

The description is extremely concise—a single sentence with no wasted words. It's front-loaded with the core action and resource, making it efficient and easy to parse, though this brevity contributes to gaps in other dimensions.

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 required parameters, mutation operation) and the presence of annotations and an output schema, the description is minimally adequate. However, it lacks details on parameter meanings and usage context, which are important for a tool with many inputs and admin-level access.

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

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

With 0% schema description coverage and 7 required parameters, the description adds no semantic information beyond the tool name. It doesn't explain what parameters like 'id', 'total_copies', or 'location' mean, failing to compensate for the lack of schema descriptions.

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

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

The description clearly states the action ('Add') and resource ('library book'), and the '[Admin]' prefix suggests administrative privileges. However, it doesn't explicitly differentiate from sibling tools like 'search_library_books' or 'check_book_availability', which are read-only operations, so it misses full sibling 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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., admin access required), exclusions, or comparisons to other book-related tools like 'search_library_books' for queries, leaving usage context vague.

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

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

Annotations indicate this is a non-destructive, open-world write operation (readOnlyHint: false, destructiveHint: false, openWorldHint: true). The description adds minimal context by implying admin-level access but doesn't detail behavioral traits like error handling, validation, or response format. No contradiction with annotations exists.

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

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

The description is extremely concise with a single sentence, front-loaded with the action and resource. There is no wasted verbiage, making it efficient, though this brevity contributes to gaps in other dimensions.

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

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

Given the complexity of a course creation tool with 5 parameters, 0% schema coverage, and no output schema details provided, the description is inadequate. It lacks essential context like parameter meanings, usage scenarios, and expected outcomes, making it incomplete for effective agent use.

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

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

With 0% schema description coverage, the schema provides only titles and types for 5 parameters. The description offers no additional semantic information about what parameters like 'code' or 'department_id' represent, failing to compensate for the lack of schema documentation.

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

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

The description clearly states the action ('Add') and resource ('course'), and the '[Admin]' prefix suggests administrative privileges. However, it doesn't differentiate from sibling tools like admin_add_department or admin_add_book beyond the resource type, missing explicit 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 no guidance on when to use this tool versus alternatives like search_courses or list_departments. It lacks context about prerequisites, such as needing admin rights or when course creation is appropriate, leaving usage unclear.

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

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

Annotations indicate this is a non-read-only, non-destructive, open-world operation. The description adds that it's for adding to 'the database', which aligns with annotations but doesn't provide extra context like permission requirements, idempotency, or error handling. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that front-loads the key information ('[Admin] Add a new academic department'). There's no wasted text, making it appropriately concise for the tool's purpose.

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

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

Given the tool has annotations and an output schema, the description covers the basic purpose but lacks details on parameters and usage context. For a mutation tool with 4 parameters and 0% schema coverage, more guidance on inputs and behavior would improve completeness, though the output schema reduces the need for return value explanation.

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

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

With 0% schema description coverage for 4 parameters, the description doesn't explain any parameters (id, name, faculty, description) beyond what the schema provides. It mentions 'new academic department' but gives no details on parameter meanings or constraints, failing to compensate for the low coverage.

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

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

The description clearly states the action ('Add') and resource ('academic department'), and the '[Admin]' prefix suggests administrative privileges. However, it doesn't explicitly differentiate from sibling tools like 'admin_add_faculty' or 'admin_add_course' beyond the resource type.

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

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

The description provides minimal guidance—it implies this is for administrative use but doesn't specify when to use it versus alternatives like 'list_departments' or prerequisites for adding a department. No explicit when/when-not 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?

Annotations indicate this is a write operation (readOnlyHint: false) with open-world data (openWorldHint: true) and non-destructive (destructiveHint: false). The description adds the date format constraint, which is useful context not covered by annotations. However, it doesn't disclose other behavioral traits like permission requirements, error handling, or response behavior, leaving gaps despite the 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, efficient sentence that front-loads the core purpose ('Add a new university event') and includes a critical detail (date format). There's no wasted verbiage, though it could be slightly more structured by separating the admin context from the action.

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 (5 required parameters, write operation) and the presence of annotations and an output schema, the description is moderately complete. It covers the action and a key parameter constraint but lacks details on usage context, permissions, or error handling. The output schema reduces the need to explain return values, but more behavioral context 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 schema provides no parameter descriptions. The description adds semantic meaning for the 'date' parameter by specifying its format (YYYY-MM-DD HH:MM:SS), which is valuable. However, it doesn't explain the other 4 parameters (id, title, location, description), leaving them undocumented. This partial compensation justifies a baseline score.

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 university event') and specifies the resource type ('university event'), which distinguishes it from other admin_add_* tools like admin_add_book or admin_add_course. However, it doesn't explicitly differentiate from admin_add_news or other event-related tools like list_upcoming_events, making it slightly less specific than 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., admin privileges implied by '[Admin]'), exclusions, or comparisons with sibling tools like admin_add_news or list_upcoming_events. The date format note is helpful but doesn't address usage context.

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

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

Annotations indicate this is a non-readOnly, non-destructive, openWorld operation. The description adds minimal behavioral context by implying an 'Admin' role requirement, but doesn't elaborate on permissions, side effects, or response behavior. With annotations covering key traits, the description adds some value but lacks depth, such as error handling or creation constraints.

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

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

The description is extremely concise with a single sentence, front-loaded with the key action and resource. There's no wasted wording, making it efficient for quick understanding, though this brevity contributes to gaps in other dimensions.

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 (6 required parameters, mutation operation) and the presence of an output schema, the description is incomplete. It lacks details on parameter meanings, usage context, and behavioral nuances, relying too heavily on structured fields without adding sufficient explanatory value.

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%, and the description provides no information about parameters beyond the tool name implying 'faculty member' data. It doesn't explain what 'id', 'designation', 'research_interests', etc., mean or their expected formats, failing to compensate for the low schema coverage.

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

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

The description clearly states the action ('Add') and resource ('a new faculty member'), and the '[Admin]' prefix suggests administrative privileges. However, it doesn't explicitly differentiate from sibling tools like 'admin_add_department' or 'admin_add_course' beyond the resource type, missing specific scope details that would warrant a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'search_faculty' for lookup or other admin_add_* tools for different resources. There's no mention of prerequisites, context, or exclusions, leaving usage unclear beyond the basic action.

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

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

Annotations indicate this is a write operation (readOnlyHint: false), non-destructive (destructiveHint: false), and open-world (openWorldHint: true). The description adds minimal context by implying admin-level access via the '[Admin]' prefix, but doesn't elaborate on behavioral traits like error conditions, validation rules, or what 'openWorldHint' means in practice (e.g., whether 'id' must be unique).

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

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

The description is extremely concise—a single sentence with no wasted words. It's front-loaded with the key action and resource, though this brevity contributes to gaps in other dimensions.

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 (admin write operation with 5 required parameters), annotations cover basic safety (non-destructive, open-world), and an output schema exists (so return values needn't be described). However, the description lacks critical context: no parameter guidance, no usage distinctions from siblings, and minimal behavioral details beyond annotations, making it incomplete for effective agent use.

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

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

Schema description coverage is 0%, meaning parameter titles (e.g., 'Id', 'Title') provide no semantic details. The description adds no information about parameters—it doesn't explain what 'id' represents (e.g., unique identifier), 'date' format, 'category' options, or content constraints. With 5 required parameters and no schema descriptions, the description fails 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 clearly states the action ('Add') and resource ('a news item'), and the '[Admin]' prefix suggests administrative privileges. However, it doesn't explicitly differentiate from sibling tools like 'admin_add_event' or 'admin_add_book' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., admin permissions), nor does it contrast with similar tools like 'get_latest_news' for reading news or other admin_add_* tools for different resources.

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

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

Annotations indicate this is a non-readOnly, non-destructive, open-world operation, but the description adds minimal context—it implies a write action ('Add') without detailing effects like persistence, validation, or error handling. It doesn't contradict annotations, but offers little beyond them, such as rate limits or auth needs, resulting in moderate value addition.

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 brief and front-loaded with the core action, but it's overly terse—a single sentence that could benefit from slightly more detail without becoming verbose. It avoids waste, but under-specification reduces its effectiveness, though not due to poor structure.

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

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

Given the complexity (8 parameters, write operation) and lack of schema descriptions, the description is incomplete. It doesn't address parameter meanings, usage context, or behavioral details, and while an output schema exists, the description doesn't hint at return values or success/failure outcomes, making it inadequate for the tool's needs.

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

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

With 0% schema description coverage and 8 required parameters, the description fails to add any semantic meaning beyond the schema. It doesn't explain what parameters like 'id', 'eligibility', or 'deadline' represent, their formats, or constraints, leaving the schema to carry the full burden without compensation.

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 the action ('Add') and resource ('scholarship opportunity'), but it's vague about what 'Add' entails—does it create a new record, append to a list, or something else? It doesn't distinguish from siblings like 'admin_add_book' or 'admin_add_course' beyond the resource type, lacking specificity about the administrative context or unique aspects of scholarship addition.

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., admin privileges), compare to siblings like 'list_scholarships' or 'get_scholarship_details', or specify scenarios for its use, leaving the agent without context for selection.

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

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

Annotations indicate the tool is read-only, non-destructive, and idempotent, which the description doesn't contradict. However, the description adds minimal behavioral context beyond the annotations, such as the input format example, but fails to explain rate limits, error handling, or output format. With annotations covering safety, a baseline score is appropriate.

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 brief and to the point, consisting of two sentences that directly state the purpose and provide an input example. It avoids unnecessary fluff, making it efficient, though it could be slightly more structured by separating usage notes from the example.

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 (single parameter with nested objects), lack of output schema, and rich annotations, the description is minimally adequate. It covers the basic function and input format but misses details like output structure, error cases, or integration with sibling tools, leaving gaps for an AI agent to infer.

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% description coverage, providing no details about the 'grades' parameter. The description adds an example structure ([{'credit_hours': 3, 'grade': 'A'}, ...]), which clarifies the expected format and key fields, partially compensating for the schema gap. However, it doesn't fully document all aspects, such as valid grade values or credit hour constraints.

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: 'Calculate GPA from a list of grades.' It specifies the verb ('Calculate') and resource ('GPA'), making the function unambiguous. However, it doesn't explicitly differentiate from the sibling tool 'get_cgpa', which might serve a similar purpose, preventing 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 like 'get_cgpa' or other academic tools in the sibling list. It lacks context about prerequisites, such as whether grades need to be in a specific format or system, and offers no exclusions or comparisons to other tools.

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

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

Annotations provide key hints: readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description adds minimal behavioral context beyond this, only specifying the input method ('using CNIC'). It doesn't contradict annotations, but offers little extra insight into rate limits, error handling, or response format.

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

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

The description is a single, efficient sentence that directly states the tool's function and input method. It is front-loaded with the core purpose and avoids any unnecessary words, making it highly concise and well-structured.

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

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

Given the tool has annotations covering safety and idempotency, an output schema exists (so return values are documented elsewhere), and only one parameter is clarified in the description, the description is reasonably complete. However, it lacks usage guidelines and differentiation from siblings, which slightly reduces completeness for an agent's decision-making.

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%, but the description mentions 'using CNIC', which clarifies the meaning of the single parameter 'cnic' beyond the schema's basic type. Since there's only one parameter and the description adds this semantic detail, it meets the baseline for adequate coverage without fully compensating for the schema gap.

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

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

The description clearly states the action ('check admission status') and the required input ('using CNIC'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_admission_form_status' or 'preview_admission_form', which could involve similar admission-related queries, leaving some ambiguity about its specific 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 no guidance on when to use this tool versus alternatives, such as 'get_admission_form_status' or 'get_admission_requirements'. It lacks context about prerequisites, timing, or exclusions, leaving the agent to infer usage based on the name alone.

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

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

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description doesn't need to repeat these. It adds value by specifying the action ('check availability for borrowing'), which isn't in the annotations, but lacks details on response format or error handling. No contradiction with annotations exists.

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

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

The description is a single, clear sentence that efficiently conveys the core purpose without unnecessary words. It's front-loaded and wastes no space, 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 simple tool with one parameter, rich annotations, and no output schema, the description is adequate but incomplete. It covers the basic action but lacks details on return values (e.g., availability status, error cases) or integration with sibling tools, leaving 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?

With 0% schema description coverage and only one parameter ('book_id'), the description doesn't add any semantic details beyond the schema. It implies the parameter is used to identify a book but doesn't explain format or constraints. The baseline is 3 due to the single parameter, but no compensation for the coverage gap.

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

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

The description clearly states the tool's purpose with a specific verb ('check') and resource ('book availability for borrowing'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'search_library_books' or 'get_borrowed_books', which limits its score to 4 rather than 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'search_library_books' or 'get_borrowed_books', nor does it mention prerequisites or exclusions. It merely states what the tool does without contextual usage instructions.

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

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

Annotations already provide strong behavioral hints (readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false). The description adds value by specifying the filtering capabilities (by hostel name or room type), which isn't covered by annotations. It doesn't contradict annotations—the 'check' action aligns with readOnlyHint=true.

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 zero waste. It's front-loaded with the core purpose ('Check available hostel rooms') followed by filtering details. Every word serves a clear function, 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 low complexity (2 optional parameters), rich annotations covering safety and behavior, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose and filtering, though it could benefit from mentioning that parameters are optional or providing example usage scenarios.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description compensates by explaining what the parameters do ('Filter by hostel name or room type'), adding semantic meaning beyond the schema's titles. However, it doesn't detail format constraints or provide examples for the string parameters.

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

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

The description clearly states the tool's purpose: 'Check available hostel rooms' specifies the verb (check) and resource (hostel rooms). It distinguishes from sibling tools like 'check_book_availability' by focusing on hostel rooms rather than books, though it doesn't explicitly contrast with other hostel-related tools like 'get_hostel_fees' or 'get_hostel_rules'.

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 implied usage guidance by mentioning filtering capabilities ('Filter by hostel name or room type'), which suggests when to use this tool for specific queries. However, it lacks explicit guidance on when to use this versus alternatives like 'get_hostel_fees' or 'get_hostel_rules', and doesn't mention 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?

Annotations already provide strong behavioral hints (readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false). The description adds value by clarifying this is an eligibility assessment tool ('may be eligible for'), which implies probabilistic or rule-based matching rather than definitive results. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core functionality.

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

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

Given the annotations provide good behavioral coverage (read-only, non-destructive, idempotent) and an output schema exists (so return values are documented elsewhere), the description is reasonably complete. However, it lacks parameter explanations and usage differentiation from siblings, which are minor 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 0%, so the schema provides no parameter descriptions. The description mentions 'based on criteria' but doesn't explain what the three parameters (cgpa, family_income, is_punjab_domicile) represent or how they affect eligibility. This leaves significant gaps in understanding parameter 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 purpose: 'Check which scholarships a student may be eligible for based on criteria.' It specifies the verb ('check'), resource ('scholarships'), and scope ('student eligibility'), but doesn't explicitly differentiate from sibling tools like 'list_scholarships' or 'get_scholarship_details'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention sibling tools like 'list_scholarships' (which might list all scholarships) or 'get_scholarship_details' (which might provide details about specific scholarships), leaving the agent to infer usage context.

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

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

Annotations indicate this is a non-read-only, non-destructive, idempotent, and open-world operation. The description adds value by specifying that submission requires confirmation ('Set confirmed=True to submit'), which isn't covered by annotations. It doesn't contradict annotations, as 'submit' aligns with readOnlyHint=false, and it provides useful context about the confirmation requirement.

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 highly concise and front-loaded, consisting of two clear sentences that directly state the tool's purpose and a key parameter requirement. There is no wasted text, and every sentence adds essential information, making it efficient and well-structured.

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

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

Given the tool's complexity (a submission operation with confirmation), annotations provide good behavioral context (non-destructive, idempotent), but there's no output schema. The description covers the core action and confirmation requirement, but it lacks details on error conditions, response format, or prerequisites. For a tool that likely has significant side effects, this is a minimal but adequate level of 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 carries the burden of explaining parameters. It mentions 'Set confirmed=True to submit,' which clarifies the semantics of the 'confirmed' parameter. However, it doesn't explain 'application_id' or provide additional details like format or constraints. With two parameters and low schema coverage, this partial compensation results in an adequate baseline score.

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: 'Submit the admission form after user confirmation.' It specifies the verb ('submit') and resource ('admission form'), and includes a condition ('after user confirmation'). However, it doesn't explicitly differentiate from sibling tools like 'submit_help_ticket' or 'preview_admission_form', which could have overlapping contexts.

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 guidelines by mentioning 'after user confirmation' and 'Set confirmed=True to submit,' suggesting this tool should be used when the user has confirmed the form. However, it doesn't provide explicit alternatives (e.g., when to use 'preview_admission_form' instead) or exclusions, leaving some ambiguity about when this tool is the best choice 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?

Annotations indicate this is a non-destructive, idempotent write operation (readOnlyHint: false, destructiveHint: false, idempotentHint: true). The description adds valuable context about the 'step by step' workflow, which isn't captured in annotations. No contradiction with annotations exists.

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 that are front-loaded with the core action. Every word contributes to understanding the tool's purpose and usage context without any redundancy or fluff.

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

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

For a write tool with no output schema and 0% parameter documentation, the description is minimally adequate. It covers the basic purpose and workflow context but lacks details on parameters, error conditions, or what happens after filling a field, leaving room for improvement given 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?

With 0% schema description coverage, the description doesn't explain any of the three parameters (application_id, field_name, field_value). It mentions 'admission form' and 'field' but provides no details about valid field names, value formats, or how to identify the application, leaving significant gaps.

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

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

The description clearly states the action ('fill a single field') and resource ('admission form'), making the purpose understandable. It distinguishes from the sibling 'fill_multiple_admission_fields' by specifying 'single field', though it doesn't explicitly name that alternative.

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 implied usage context with 'step by step', suggesting incremental form completion. However, it lacks explicit guidance on when to use this versus alternatives like 'fill_multiple_admission_fields' or 'confirm_and_submit_admission_form', and doesn't mention 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?

Annotations indicate this is a non-destructive, idempotent write operation (readOnlyHint: false, destructiveHint: false, idempotentHint: true). The description adds value by specifying it handles 'multiple fields at once', which clarifies batch behavior not captured in annotations. It doesn't contradict annotations, though it could mention more about effects or constraints.

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

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

The description is extremely concise with two sentences that directly state functionality and input format. Every word serves a purpose, and it's front-loaded with the core action, making it efficient 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?

For a write tool with 2 parameters, 0% schema coverage, no output schema, and nested objects, the description is minimal. It covers the batch nature and input structure but lacks details on field validation, error handling, or output. With annotations providing safety context, it's adequate but not comprehensive.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'fields' as a dictionary mapping field names to values, adding useful semantics beyond the schema's generic object type. However, it doesn't clarify 'application_id' or provide examples of valid field names/values, leaving gaps.

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

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

The description clearly states the action ('fill multiple fields at once') and resource ('admission fields' implied by tool name), making the purpose understandable. However, it doesn't explicitly differentiate from its sibling 'fill_admission_field' (which presumably fills single fields), missing full sibling 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 no guidance on when to use this tool versus alternatives like 'fill_admission_field' or 'confirm_and_submit_admission_form'. It lacks context about prerequisites, timing, or exclusions, offering only basic functional information.

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

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

Annotations already provide comprehensive behavioral hints (read-only, non-destructive, idempotent, closed-world). The description adds minimal context about the 'near a location' scope but doesn't disclose additional behavioral traits like distance limits, result formats, or performance characteristics that would be helpful beyond the 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 perfectly concise - a single sentence that immediately communicates the core functionality without any unnecessary words. It's front-loaded with the essential information and earns its place efficiently.

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

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

Given the tool's simplicity (single parameter, comprehensive annotations, existence of output schema), the description is reasonably complete. The output schema will handle return value documentation, and annotations cover safety aspects. However, more guidance about usage context would make it more 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?

With 0% schema description coverage and only one parameter, the description adds some semantic context by indicating the parameter should be a 'location', but doesn't specify format (e.g., address, coordinates), validation rules, or examples. The baseline is appropriate given the single parameter, but more detail would improve understanding.

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

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

The description clearly states the tool's purpose with a specific verb ('find') and resource ('bus stops near a location'), making it immediately understandable. However, it doesn't explicitly differentiate from its only sibling tool 'get_bus_routes', which could be a related but distinct 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 provides no guidance on when to use this tool versus alternatives like 'get_bus_routes' or other location-based tools. It lacks context about prerequisites, limitations, or specific scenarios where this tool is preferred over other options.

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

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

Annotations already indicate this is a read-only, non-destructive, idempotent operation with a closed-world scope. The description adds no behavioral context beyond this, such as rate limits, authentication needs, or error conditions. However, it doesn't contradict the annotations, so it meets the lower bar set by their presence.

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

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

The description is a single, efficient sentence that front-loads the core purpose. Every word contributes meaning without 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?

Given the simple input schema (one parameter), rich annotations covering safety and behavior, and no output schema, the description is adequate but minimal. It lacks details on return values (e.g., format of status data) and doesn't fully address the tool's role among siblings, leaving some contextual gaps.

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

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

Schema description coverage is 0%, but the description doesn't add any parameter details beyond what's implied by the tool name. It doesn't explain the 'application_id' parameter's format, source, or constraints. With only one parameter and no schema descriptions, the baseline is 3, as the description doesn't compensate for the lack of schema coverage.

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

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

The description clearly states the verb 'Get' and the resource 'admission form status', specifying what information is included ('collected and missing fields'). It distinguishes from some siblings like 'check_admission_status' by focusing on form field details rather than overall application status, though it doesn't explicitly contrast with all relevant siblings like 'preview_admission_form'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing admission form), exclusions, or comparisons to siblings like 'preview_admission_form' or 'check_admission_status', leaving the agent to infer usage context.

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

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

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description doesn't need to repeat these. It adds minimal context by specifying 'admission requirements and eligibility criteria', but doesn't disclose additional details like response format or any constraints beyond what annotations provide.

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

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

The description is a single, efficient sentence that directly states the tool's function without any unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly.

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

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

Given the tool's simplicity (0 parameters, no output schema) and rich annotations, the description is adequate but minimal. It covers the basic purpose but lacks details on output format or usage context, which could be helpful for an agent despite the 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?

With 0 parameters and 100% schema description coverage, the schema fully documents the input structure. The description doesn't need to add parameter details, and it appropriately focuses on the tool's purpose without redundancy, earning a baseline score for zero-parameter tools.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('admission requirements and eligibility criteria'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'get_available_programs' or 'check_admission_status', which might have overlapping contexts.

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. With siblings such as 'check_admission_status' and 'get_available_programs', there's no indication of when this tool is preferred or what specific scenarios it addresses, leaving usage ambiguous.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds no behavioral context beyond what annotations declare (e.g., no rate limits, authentication needs, or data freshness). It doesn't contradict annotations, so it meets the lower bar with annotations present.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core purpose and efficiently conveys the tool's function without unnecessary elaboration, making it easy to parse quickly.

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

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

Given the tool's simplicity (0 parameters, annotations covering safety, and an output schema present), the description is reasonably complete. It states what the tool does, and with output schema handling return values, no additional detail is strictly needed. However, it could benefit from usage context given sibling tools.

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

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

With 0 parameters and 100% schema description coverage, the schema fully documents the lack of inputs. The description doesn't need to compensate for missing parameter info, and it appropriately doesn't mention parameters. A baseline of 4 is justified as the description doesn't mislead about parameters.

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

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

The description clearly states the verb ('Get') and resource ('list of available programs for admission'), making the purpose specific and understandable. It doesn't explicitly differentiate from siblings like 'list_departments' or 'get_admission_requirements', but the focus on 'programs for admission' provides reasonable 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 no guidance on when to use this tool versus alternatives. With siblings like 'get_admission_requirements' and 'list_departments' that might overlap in context, there's no indication of when this specific tool is appropriate or what distinguishes it from similar 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?

Annotations already cover key behavioral traits: read-only, non-destructive, idempotent, and closed-world. The description adds minimal value beyond this, only implying it returns a list of current borrowings. It doesn't disclose additional context like authentication needs, rate limits, or error conditions, but doesn't contradict the annotations either.

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

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

The description is a single, clear sentence that efficiently conveys the core functionality without unnecessary words. It's front-loaded with the main action and resource, making it easy to parse and understand quickly.

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

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

Given the tool's low complexity (one parameter), rich annotations covering safety and behavior, and the presence of an output schema (which handles return values), the description is reasonably complete. It could be improved with more usage guidance, but the structured data compensates well for the 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?

With 0% schema description coverage, the schema provides no parameter details. The description mentions 'by a student', which hints at the 'student_id' parameter's purpose, but doesn't explain format, constraints, or examples. This partial compensation keeps it at the baseline for minimal parameter insight.

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 list') and resource ('books currently borrowed by a student'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'check_book_availability' or 'search_library_books', which might also involve book-related queries, so it doesn't reach the highest 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. For example, it doesn't specify if this is for current borrowings only versus historical data, or how it differs from 'check_book_availability'. Without such context, the agent must infer usage from the tool name alone.

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

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

Annotations already provide clear hints (readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false), indicating safe, read-only behavior. The description adds value by specifying the filtering capability ('Optionally filter by route name'), which isn't covered by annotations, enhancing context without contradiction.

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

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

The description is extremely concise—two short sentences that are front-loaded with the main purpose and immediately follow with parameter guidance. Every word earns its place, with no redundancy or fluff.

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

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

Given the tool's low complexity (one optional parameter), rich annotations covering safety and behavior, and the presence of an output schema (which handles return values), the description is complete enough. It provides essential purpose and parameter info without overloading.

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 carries the burden. It effectively explains the optional 'route_name' parameter for filtering, adding meaningful semantics beyond the bare schema. With only one parameter, this is sufficient for a high score, though it could detail format or 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 verb ('Get') and resource ('university bus routes'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from its sibling 'get_route_by_stop' or other transport-related tools, which would be needed for 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 implies usage context through 'Optionally filter by route name,' suggesting when to use the optional parameter. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_route_by_stop' or other filtering methods, leaving some ambiguity.

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 annotations already provide key behavioral hints: readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description does not contradict these annotations, as 'Get' aligns with read-only and non-destructive operations. However, it adds minimal context beyond the annotations, such as not specifying if the tool requires authentication or details on rate limits, so it only partially enhances 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, clear sentence: 'Get cumulative GPA and academic standing for a student.' It is front-loaded with the core action and resource, with no unnecessary words or redundant information, making it highly efficient and easy to parse.

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

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

Given the tool's low complexity (one parameter, no nested objects) and rich annotations (covering read-only, non-destructive, idempotent, and closed-world aspects), the description is adequate but not complete. It lacks details on output format (e.g., numeric GPA, standing categories) and any edge cases, which could be important for an agent. With no output schema, the description should ideally provide more context on return values, but it does not.

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 one parameter, 'student_id', with 0% schema description coverage, meaning the schema provides no descriptive details. The description does not explicitly mention this parameter or its semantics, but since there is only one parameter and the tool's purpose is straightforward, the agent can infer that 'student_id' is needed to retrieve the GPA and academic standing. This compensates adequately for the lack of schema coverage, though not perfectly.

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 cumulative GPA and academic standing for a student.' It specifies the verb ('Get') and the resources ('cumulative GPA and academic standing'), making it easy to understand what the tool does. However, it does not explicitly differentiate from the sibling tool 'calculate_gpa', which might be a related but distinct operation, so it falls short of 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, such as the sibling tool 'calculate_gpa'. It lacks context on prerequisites, exclusions, or specific scenarios where this tool is appropriate, leaving the agent to infer usage based on the name and description alone.

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

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

Annotations already provide key behavioral hints (read-only, non-destructive, idempotent, closed-world). The description adds minimal context by mentioning filtering capabilities, but doesn't disclose additional traits like rate limits, authentication needs, or response format details. With annotations covering safety, 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 extremely concise—two sentences that directly state the tool's function and filtering options without any fluff. It's front-loaded and every word serves a purpose, 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 low complexity (simple read operation), rich annotations (covering safety and idempotency), and the presence of an output schema (which handles return values), the description is reasonably complete. It could improve by clarifying sibling distinctions or parameter details, but it's sufficient for basic use.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description mentions filtering by 'course code or day of week', which adds some meaning to the two parameters, but doesn't specify format (e.g., day abbreviations), constraints, or interaction effects. This partially compensates but leaves gaps.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('class schedule'), and mentions filtering capabilities. However, it doesn't differentiate from sibling tools like 'get_today_classes' or 'get_exam_schedule', which also retrieve schedule-related information, so it doesn't fully distinguish itself from alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_today_classes' or 'get_exam_schedule'. It mentions filtering options but doesn't specify contexts or exclusions, leaving the agent to infer usage based on parameter names alone.

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

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

Annotations cover key traits: read-only, non-destructive, idempotent, and closed-world. The description adds context by specifying the optional filtering capability, which isn't in annotations. However, it doesn't disclose additional behaviors like rate limits, error handling, or what 'contact information' entails (e.g., phone, email). No contradiction with annotations exists.

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

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

The description is two sentences, front-loaded with the core purpose and followed by the filtering detail. Every word earns its place with no redundancy or fluff, making it highly efficient and easy to parse for an AI 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's low complexity (one optional parameter), rich annotations (covering safety and idempotency), and the presence of an output schema (which handles return values), the description is mostly complete. It covers the purpose and parameter use but lacks guidance on when to use versus siblings, which is a minor 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?

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that the parameter 'department_name' is for optional filtering, clarifying its purpose beyond the schema's title 'Department Name.' With only one parameter, this is sufficient, but it doesn't detail format constraints (e.g., exact names vs. partial matches).

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 contact information for university departments.' It specifies the verb ('Get') and resource ('contact information for university departments'), making the function unambiguous. However, it doesn't explicitly differentiate from siblings like 'list_departments' or 'get_university_info,' which could provide overlapping information.

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

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

The description provides minimal guidance: 'Optionally filter by name.' It implies usage for retrieving department contacts but offers no explicit when-to-use advice, such as when to choose this over 'list_departments' for contact details versus general listings, or prerequisites like authentication needs. There's no mention of alternatives 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?

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description doesn't need to repeat these. It adds minimal context by specifying 'emergency contact numbers,' but doesn't disclose additional traits like response format, rate limits, or authentication needs. No contradiction with 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, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the tool's low complexity (0 parameters, no output schema) and rich annotations, the description is minimally adequate. It specifies the resource type but lacks details on return values or behavioral nuances, leaving some gaps for an agent to infer usage in context with 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?

With 0 parameters and 100% schema description coverage, the schema fully documents the lack of inputs. The description doesn't add parameter details, which is unnecessary here, so it meets the baseline for a parameterless tool without compensation 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 verb ('Get') and resource ('emergency contact numbers for the university'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from potential siblings like 'get_department_contact' or 'get_university_info', which might also provide contact information, so it misses 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?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_department_contact' and 'get_university_info' that might overlap in providing contact details, there's no indication of context, prerequisites, or exclusions, leaving usage ambiguous.

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

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

Annotations already provide strong behavioral hints (readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=false), covering safety and idempotency. The description adds minimal context about filtering capabilities but doesn't disclose additional traits like rate limits, authentication needs, or what 'exam schedule' entails (e.g., date ranges, formats). With annotations doing heavy lifting, the description adds some value but not rich behavioral details.

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

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

The description is extremely concise (two short sentences) and front-loaded with the core purpose. Every word earns its place: 'Get exam schedule' states the action, and the second sentence adds essential filtering info without redundancy. No waste or unnecessary elaboration.

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

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

Given the tool's low complexity (simple read operation with 2 optional parameters), rich annotations (covering safety and behavior), and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose and basic filtering, though it could add more on scope (e.g., time range) or prerequisites. For this context, it's mostly sufficient.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description compensates by explaining that parameters are for filtering ('Filter by course code or exam type'), adding meaning beyond the bare schema. However, it doesn't specify format (e.g., exam type values like 'Midterm/Final' are mentioned but not exhaustive) or usage details, leaving gaps. Baseline would be lower without this, but it's adequate given 0% coverage.

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

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

The description clearly states the tool's purpose: 'Get exam schedule' specifies the verb (get) and resource (exam schedule). It distinguishes this tool from siblings like 'get_class_schedule' or 'get_today_classes' by focusing on exams rather than regular classes. However, it doesn't explicitly differentiate from all possible exam-related tools (none exist in siblings), so it's not a perfect 5.

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

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

The description implies usage context by mentioning filtering options ('Filter by course code or exam type'), suggesting when to use this tool for specific queries. However, it doesn't provide explicit guidance on when to use this vs. alternatives (e.g., 'get_class_schedule' for non-exam schedules) or any exclusions. The guidance is present but not comprehensive.

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

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

Annotations cover key behavioral traits: read-only, non-destructive, idempotent, and closed-world. The description adds no additional behavioral context beyond these annotations, such as rate limits, authentication needs, or error handling. However, it doesn't contradict the annotations, so it meets the lower bar set by their presence.

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

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

The description is a single, clear sentence that efficiently conveys the core purpose without unnecessary words. It's front-loaded with the main action and resource, making it easy to parse and understand quickly.

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

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

Given the tool's low complexity (one parameter, read-only operation), annotations covering safety and behavior, and the presence of an output schema (which handles return values), the description is reasonably complete. It could improve by adding usage guidelines or parameter details, but it suffices for basic understanding in this context.

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

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

Schema description coverage is 0%, but the description adds minimal semantic context by implying the 'program' parameter specifies an academic program. It doesn't detail format, examples, or constraints beyond what the schema's title ('Program') provides. With one parameter and no schema descriptions, the baseline is 3 as it partially compensates but lacks depth.

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 fee details for a specific academic program.' It specifies the verb ('Get') and resource ('fee details'), and distinguishes it from siblings like 'get_hostel_fees' by focusing on academic programs. However, it doesn't explicitly differentiate from potential similar tools beyond the sibling list.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for use, or compare it to related tools like 'get_scholarship_details' or 'get_financial_aid_office_info' for broader financial inquiries. Usage is implied but not explicitly stated.

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

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

Annotations already cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description doesn't need to repeat these. It adds no additional context about what specific contact information is returned, format, or any limitations, but doesn't contradict annotations, so it meets the baseline for having 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, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse for an AI 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's simplicity (0 parameters, annotations covering safety), the description is minimally adequate. However, with no output schema, it doesn't specify what contact information is returned (e.g., phone, email, hours), leaving a gap in completeness for an agent needing to understand the response.

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

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

The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to explain parameters, so it naturally compensates by focusing on the tool's purpose. A score of 4 reflects that it adequately handles the no-parameter case without unnecessary detail.

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

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

The description clearly states the verb ('Get') and resource ('contact information for the Financial Aid Office'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from similar tools like 'get_department_contact' or 'get_university_info' which might also provide contact information, so it doesn't reach the highest 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. There are sibling tools like 'get_department_contact' and 'get_university_info' that might overlap in functionality, but no explicit comparison or context is given to help an agent choose appropriately.

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

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

Annotations indicate read-only, non-destructive, and idempotent operations, which the description doesn't contradict. However, the description adds no behavioral context beyond this—e.g., it doesn't mention if it returns real-time data, historical info, or requires authentication. With annotations covering safety, the description provides limited extra value, earning a baseline score.

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 hostel fee structure') that front-loads the purpose without unnecessary words. It's appropriately sized for a simple tool, though it could be slightly more informative without losing conciseness. Every word earns its place, but it borders on under-specification.

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

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

Given the tool's simplicity (0 parameters, annotations provide safety info, no output schema), the description is minimally adequate. However, it lacks details on what 'fee structure' includes (e.g., costs, deadlines, payment methods) and doesn't clarify scope compared to siblings. For a read-only tool, it's passable but has clear gaps in contextual richness.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter details, but that's acceptable here. A baseline of 4 is appropriate as the schema fully handles the lack of parameters, and the description doesn't 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 'Get hostel fee structure' clearly states the verb ('Get') and resource ('hostel fee structure'), but it's vague about what 'fee structure' entails (e.g., rates, policies, breakdowns). It doesn't distinguish from sibling tools like 'get_fee_structure' (which might be general fees) or 'check_hostel_availability' (related but different purpose), leaving ambiguity in scope.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this is for current students, prospective ones, or administrators, or how it differs from 'get_fee_structure' or other fee-related tools. The description lacks context, prerequisites, or exclusions, offering minimal help for selection.

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

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

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description's burden is lower. It adds no additional context beyond the verb 'Get', such as response format, authentication needs, or rate limits. No contradiction with annotations exists, but minimal value is added.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to scan. Every part of the sentence contributes directly to understanding the tool's function.

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

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

Given the tool's simplicity (0 parameters, annotations covering safety, output schema present), the description is reasonably complete. It states what the tool does, and the output schema handles return values. However, it lacks context on scope or differentiation from siblings, which could be useful 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?

With 0 parameters and 100% schema description coverage, the baseline is high. The description doesn't need to explain parameters, as the schema fully documents the empty input. No compensation is required, and the description appropriately avoids redundant parameter details.

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

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

The description states the tool's purpose ('Get hostel rules and regulations'), which is clear but vague. It specifies the resource ('hostel rules and regulations') but lacks details about scope or format. It doesn't differentiate from siblings like 'get_hostel_fees', leaving ambiguity about what distinguishes these 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context, or exclusions. With siblings like 'get_hostel_fees' and 'check_hostel_availability', there's no indication of how this tool fits into the broader workflow, leaving usage decisions unclear.

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

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

Annotations cover key traits (read-only, non-destructive, idempotent, closed-world), but the description adds value by specifying 'important' links, implying a curated subset rather than all links. It doesn't contradict annotations, and the added context is useful for understanding scope.

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

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

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

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

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

For a simple read-only tool with good annotations and no parameters, the description is adequate but lacks output details (no schema) and doesn't clarify scope relative to siblings. It's minimally viable, with clear gaps in usage context and return value explanation.

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

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

With 0 parameters and 100% schema coverage, the baseline is 4 as no parameter documentation is needed. The description doesn't add param details, but that's acceptable given the empty schema, so it meets expectations without 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 verb 'Get' and the resource 'important university website links', making the purpose specific and understandable. However, it doesn't differentiate from siblings like 'get_university_info' or 'get_department_contact' that might also provide links, leaving some ambiguity about uniqueness.

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. With many sibling tools that might overlap (e.g., 'get_university_info'), the description lacks explicit context, prerequisites, or exclusions, offering minimal help for selection.

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

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

Annotations already provide comprehensive behavioral hints (read-only, non-destructive, idempotent, closed-world), so the description doesn't need to repeat these. It adds minimal value by specifying 'latest' news, implying recency, but doesn't disclose additional behavioral traits like pagination behavior, rate limits, or authentication requirements beyond what annotations provide.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core purpose and appropriately sized for a simple retrieval tool, making it easy for an agent 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 simple read-only tool with comprehensive annotations and an output schema, the description is reasonably complete. It states what the tool does, though it lacks parameter explanations and usage context. The annotations cover safety and behavioral aspects, and the output schema handles return values, reducing the description's burden.

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

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

With 0% schema description coverage, the schema provides no parameter descriptions. The tool description mentions 'latest news' but doesn't explain what 'limit' or 'offset' parameters mean or how they affect results. This leaves parameters semantically undocumented, though the presence of an output schema slightly mitigates this gap.

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

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

The description clearly states the verb 'Get' and resource 'latest news and announcements', making the purpose immediately understandable. However, it doesn't differentiate from potential sibling tools like 'admin_add_news' or 'list_upcoming_events' that might also involve news-related operations, preventing 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. There's no mention of when this tool is appropriate versus 'admin_add_news' (for creating news) or 'list_upcoming_events' (which might include news-like content), leaving the agent without contextual usage instructions.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description doesn't contradict these but adds minimal behavioral context beyond the basic operation. It doesn't mention what format the hours are returned in, whether it's real-time data, or any limitations.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple tool with no parameters. Every word earns its place.

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

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

For a simple read-only tool with good annotations but no output schema, the description is minimally adequate. It states what the tool does but lacks details about return format, data freshness, or error conditions. Given the complexity is low, it's complete enough to be functional but could be more informative.

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

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

With 0 parameters and 100% schema description coverage, the baseline is 4. The description doesn't need to explain parameters, and it doesn't introduce any confusion about inputs. It appropriately focuses on the tool's purpose rather than parameter details.

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

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

The description clearly states the verb 'Get' and resource 'library operating hours', making the purpose specific and understandable. However, it doesn't differentiate from potential sibling tools like 'get_university_info' or 'get_important_links' that might also provide hours information, preventing 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. With many sibling tools available (like 'get_university_info' which might include hours), there's no indication of context, prerequisites, or exclusions for this specific 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?

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description's burden is lower. It adds context by specifying 'latest' and 'Spring 2026', which hints at temporal scope, but doesn't disclose additional details like rate limits, authentication needs, or data freshness. No contradiction with 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, efficient sentence with no wasted words. It's front-loaded with the core action and resource, 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 has annotations covering safety and behavior, an output schema exists (so return values are documented elsewhere), and it's a simple read operation with one parameter, the description is moderately complete. However, it lacks usage guidelines and deeper parameter context, which could aid agent decision-making.

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 implies 'dept_id' is needed for a department-specific merit list, but doesn't explain format, valid values, or constraints. With one parameter and no schema descriptions, this provides minimal semantic value beyond the schema's structure.

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 resource ('merit list') with specific context ('latest', 'for a department', 'Spring 2026'), making the purpose evident. However, it doesn't explicitly differentiate from potential siblings like 'get_semester_result' or 'get_cgpa', which might also relate to academic performance data.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare it to sibling tools such as 'get_semester_result' or 'get_cgpa', leaving usage context unclear.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=false, and idempotentHint=true, covering safety and idempotency. The description adds value by specifying the resource ('hostel mess menu') and optional filtering, which aren't covered by annotations, but doesn't disclose additional behavioral traits like rate limits or auth needs.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get hostel mess menu') and adds an optional detail ('Optionally filter by day') without waste. Every word contributes to understanding the tool's functionality.

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

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

Given the tool's low complexity (one optional parameter), rich annotations (covering safety and idempotency), and the presence of an output schema (which handles return values), the description is mostly complete. It could improve by specifying the format for 'day' or mentioning sibling tools, but it adequately supports the agent's needs.

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

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

Schema description coverage is 0%, with one parameter ('day') documented only by title in the schema. The description compensates by explaining that filtering by day is optional, adding meaning beyond the schema. However, it doesn't specify the format or allowed values for 'day' (e.g., weekdays, dates).

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

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

The description clearly states the verb ('Get') and resource ('hostel mess menu') with an optional scope ('filter by day'), making the purpose specific and understandable. However, it doesn't differentiate from potential siblings like 'get_hostel_fees' or 'get_hostel_rules', which are related but distinct 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 implies usage context by mentioning 'hostel mess menu' and optional filtering by day, but it lacks explicit guidance on when to use this tool versus alternatives (e.g., no comparison to other hostel-related tools like 'get_hostel_fees'). The context is clear but not comprehensive for sibling differentiation.

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

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

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the bar is lower. The description adds value by specifying the filtering logic ('pass through a specific stop'), which isn't captured in annotations. It doesn't contradict annotations and provides useful operational context, though it could mention more about output format or limitations.

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

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

The description is a single, clear sentence that front-loads the core functionality without unnecessary words. It efficiently conveys the tool's purpose and filtering logic, making it easy to parse and understand quickly.

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

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

Given the tool's low complexity (1 parameter), rich annotations, and presence of an output schema, the description is reasonably complete. It covers the main purpose and filtering aspect, and the output schema likely handles return values. However, it could be more comprehensive by mentioning potential edge cases or linking to sibling tools for better context.

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

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

The input schema has 1 parameter with 0% description coverage, but the description compensates by clarifying that 'stop_name' is used to find routes passing through it. However, it doesn't add details like format examples or constraints beyond the basic meaning. With schema coverage low, the description does some work but not fully, aligning with the baseline for minimal param info.

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 ('Find') and resource ('bus routes'), and specifies the condition ('that pass through a specific stop'). It distinguishes from sibling tools like 'get_bus_routes' by focusing on routes filtered by stop. However, it doesn't explicitly differentiate from 'find_bus_stop', which might be a related but distinct 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 usage when needing routes for a particular stop, but provides no explicit guidance on when to use this tool versus alternatives like 'get_bus_routes' (which might list all routes) or 'find_bus_stop' (which might locate stops). It lacks clear exclusions or prerequisites, leaving usage context somewhat 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?

Annotations already provide strong behavioral hints (readOnly, non-destructive, idempotent, closed-world), so the bar is lower. The description adds minimal value by implying it returns detailed information, but doesn't disclose specifics like response format, error conditions, or data freshness. It doesn't contradict annotations, earning a baseline score for not repeating structured data.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence ('Get detailed information about a specific scholarship') directly contributes to understanding the tool's function, making it optimally 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?

Given the tool's low complexity (one parameter), rich annotations (covering safety and behavior), and the presence of an output schema (handling return values), the description is reasonably complete. It states the core action clearly, though it could improve by addressing usage context or parameter details to be fully comprehensive.

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

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

Schema description coverage is 0%, but the description doesn't compensate by explaining the 'scholarship_id' parameter (e.g., format, source, or examples). However, with only one required parameter and an output schema likely defining the return structure, the baseline score of 3 is appropriate—adequate but with clear gaps in parameter documentation.

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

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

The description clearly states the verb 'Get' and resource 'detailed information about a specific scholarship', making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'list_scholarships' or 'check_scholarship_eligibility', which would require explicit differentiation to earn 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. There's no mention of prerequisites (e.g., needing a scholarship ID), comparison to 'list_scholarships' for browsing, or 'check_scholarship_eligibility' for assessment. Without this context, the agent must infer usage from the tool name alone.

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

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

Annotations cover read-only, non-destructive, and idempotent behavior, so the description doesn't need to repeat these. It adds value by specifying the optional semester filter, which provides context on how results are scoped. No contradiction with annotations, and it complements them with practical usage 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 front-loaded with the core purpose in the first clause and adds optional filtering in the second. It's appropriately sized with zero wasted words, 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 low complexity (read-only query), rich annotations (covering safety and idempotency), and the presence of an output schema (which handles return values), the description is sufficiently complete. It covers the essential what and how, though it could benefit from more usage context relative 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?

Schema description coverage is 0%, but the description adds meaning by explaining that 'student_id' is for identifying the student and 'semester' is an optional filter. However, it doesn't detail parameter formats or constraints beyond what's implied. With two parameters and no schema descriptions, this provides basic compensation but remains minimal.

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 academic results for a student' specifies the verb (get) and resource (academic results), and 'Optionally filter by semester' adds scope. It distinguishes from siblings like 'get_cgpa' or 'get_transcript_request_info' by focusing on semester-specific results, 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 needing student results with optional semester filtering, but provides no explicit guidance on when to use this versus alternatives like 'get_cgpa' for GPA or 'get_transcript_request_info' for transcripts. It mentions the optional filter but doesn't clarify 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?

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description doesn't need to repeat these. It adds value by specifying 'today' as the temporal scope, but doesn't disclose other behaviors like response format, pagination, or error handling, which are relevant given the output schema exists but isn't detailed here.

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, direct sentence with no wasted words, front-loading the core action and scope efficiently. It's appropriately sized for a simple, parameter-less tool.

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

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

Given the tool's simplicity (0 parameters, annotations provided, output schema exists), the description is minimally adequate but lacks depth. It doesn't explain what 'classes' entail (e.g., format, fields) or how 'today' is determined (e.g., timezone), which could be helpful despite the output schema covering return values.

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

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

With 0 parameters and 100% schema description coverage, the schema fully documents the absence of inputs. The description adds no parameter information, which is appropriate here, so it meets the baseline for this condition without needing compensation.

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

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

The description clearly states the verb ('Get') and resource ('classes scheduled for today'), making the purpose specific and understandable. However, it doesn't explicitly distinguish itself from the sibling tool 'get_class_schedule', which might be a broader or different version of class retrieval, leaving room for potential confusion.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_class_schedule' or other scheduling tools in the sibling list. It lacks context about prerequisites, such as user authentication or date/time considerations, which could affect its applicability.

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

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

Annotations cover read-only, non-destructive, and idempotent behavior, but the description adds value by implying this is for 'official transcripts,' suggesting formal or verified information. It doesn't contradict annotations, and while it doesn't detail rate limits or auth needs, it provides useful context beyond the structured hints.

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

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

The description is a single, clear sentence that is front-loaded and wastes no words. It directly communicates the tool's function without unnecessary elaboration, making it highly efficient and easy to 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 simplicity (0 parameters, no output schema) and rich annotations, the description is adequate but minimal. It covers the basic purpose but lacks details on usage context or behavioral nuances, leaving some gaps in completeness for an agent to fully leverage 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?

With 0 parameters and 100% schema description coverage, the baseline is 4 as per rules. The description doesn't need to explain parameters, and it efficiently states the tool's purpose without redundancy, adding no param info but not required to.

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 as 'Get information about requesting official transcripts,' which specifies the verb ('Get information about') and resource ('requesting official transcripts'). It distinguishes from siblings like 'get_transport_card_info' or 'get_scholarship_details' by focusing on transcripts, but doesn't explicitly differentiate from similar 'get_' tools beyond the topic.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, such as whether it's for students, administrators, or general inquiries, or if it should be used before or after other transcript-related tools (though none are listed in 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?

Annotations cover read-only, non-destructive, and idempotent behavior, but the description adds context by implying it retrieves general card information without specifying format or limitations. It doesn't contradict annotations, and with annotations present, the bar is lower—the description provides some useful context beyond the structured hints.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for a simple tool, 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 low complexity (0 parameters, no output schema) and rich annotations, the description is minimally adequate. However, it lacks details on what information is returned (e.g., card status, balance, validity) which would help an agent understand the tool's output, especially without 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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param details, but that's acceptable given the baseline of 4 for zero parameters—it adequately states the tool's purpose without unnecessary complexity.

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 'Get information about university transport card' clearly states the verb ('Get') and resource ('university transport card'), but it's vague about what specific information is retrieved. It doesn't distinguish from siblings like 'get_bus_routes' or 'find_bus_stop' that might also relate to transport.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this is for cardholder details, balance, or usage history, nor does it reference sibling tools like 'get_user_profile' that might overlap with personal transport info.

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

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

Annotations already declare this as read-only, non-destructive, idempotent, and closed-world, which covers key behavioral traits. The description doesn't add behavioral context beyond these annotations, but it also doesn't contradict them. Since annotations provide good coverage, the bar is lower, and the description doesn't need to repeat this information.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to parse. Every word earns its place by conveying the essential action and target.

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

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

Given the tool's simplicity (0 parameters, no output schema) and rich annotations, the description is minimally adequate. However, it lacks detail on what 'general university information' includes, which could be important for an agent to decide when to use this tool over more specific siblings. The annotations cover safety and behavior, but the description doesn't fully compensate for the vagueness in purpose.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't discuss parameters, which is appropriate. A baseline of 4 is applied for tools with no parameters, as there's nothing to compensate for.

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 'Get general university information' states a clear verb ('Get') and resource ('general university information'), but it's vague about what specific information is included. It doesn't distinguish this tool from potential siblings like 'get_important_links' or 'get_latest_news', which might also provide university information.

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. With many sibling tools that provide specific university information (e.g., 'get_fee_structure', 'get_library_hours'), there's no indication whether this tool aggregates such information or serves a different 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?

Annotations already provide clear behavioral hints (readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=false), so the description doesn't need to repeat safety information. However, it adds no additional behavioral context beyond what annotations cover—such as rate limits, authentication needs, or what specific profile fields are returned. With annotations doing most of the work, the description adds minimal value here.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action ('Get profile information'), making it easy to parse. Every part of the sentence contributes meaning, with zero waste 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 the tool's low complexity (one parameter), rich annotations covering safety and idempotency, and the presence of an output schema, the description is reasonably complete. It clearly states what the tool does, though it lacks usage guidelines and parameter details. For a simple read operation with good structural support, this is sufficient but not exceptional.

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%, but the description doesn't compensate by explaining the 'user_id' parameter's meaning, format, or sourcing. Since there's only one parameter and an output schema exists, the baseline is 3—adequate but with clear gaps. The description fails to add any semantic details beyond the schema's basic structure.

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

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

The description clearly states the verb ('Get') and resource ('profile information for a university member'), making the purpose unambiguous. It distinguishes itself from sibling tools like 'get_cgpa' or 'get_transcript_request_info' by focusing on general profile data rather than specific academic or administrative information. However, it doesn't explicitly differentiate from tools like 'search_faculty' that might also retrieve profile data, preventing 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., needing a user_id), exclusions, or comparisons to sibling tools like 'search_faculty' or 'get_department_contact' that might retrieve similar information. Without any usage context, the agent must infer when this tool is appropriate.

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

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

Annotations already provide comprehensive behavioral hints (read-only, non-destructive, idempotent, closed-world). The description adds no additional behavioral context beyond what annotations declare. It doesn't mention pagination behavior, return format, or any constraints beyond the basic purpose.

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

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

The description is a single, efficient sentence that states the core purpose without any wasted words. It's appropriately sized for a simple list operation and front-loads the 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?

For a simple list operation with comprehensive annotations and an output schema, the description is reasonably complete. The annotations cover safety and behavioral aspects, and the output schema will document return values. The main gap is the lack of parameter guidance, but given the tool's simplicity, this is less critical.

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

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

With 0% schema description coverage, the schema provides no parameter documentation. The description mentions no parameters at all, failing to compensate for the schema gap. However, since there are only 2 parameters (limit/offset) with clear default values in the schema, the baseline of 3 is appropriate as the schema structure itself provides some guidance.

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

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

The description clearly states the verb ('List') and resource ('academic departments'), making the purpose immediately understandable. However, it doesn't differentiate this tool from potential sibling list tools (like 'list_scholarships' or 'list_upcoming_events') beyond specifying the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when this tool is appropriate versus other department-related tools (like 'get_department_contact' or 'admin_add_department'), or any contextual limitations.

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

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

Annotations already provide strong behavioral hints (readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=false), so the description doesn't need to repeat safety information. The description adds value by mentioning the optional filtering capability, but doesn't provide additional behavioral context like pagination behavior (implied by limit/offset parameters) or rate limits.

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

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

The description is perfectly concise - a single sentence that states the core purpose upfront and includes the optional filtering capability. Every word serves a purpose with zero wasted text, making it easy for an AI agent 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 has comprehensive annotations covering safety and behavior, an output schema exists (so return values are documented elsewhere), and the tool's purpose is straightforward (list operation with filtering), the description provides adequate context. The main gap is the lack of explicit differentiation from sibling scholarship-related tools.

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

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

With 0% schema description coverage, the schema provides only parameter names and types without descriptions. The description mentions 'Optionally filter by provider' which explains the purpose of one parameter, but doesn't address the 'limit' and 'offset' parameters for pagination control. This provides some value but doesn't fully compensate for the schema coverage gap.

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

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

The description clearly states the verb ('List') and resource ('available scholarships'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'get_scholarship_details' or 'check_scholarship_eligibility', which would require more specific 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?

The description provides minimal guidance with 'Optionally filter by provider' but doesn't explain when to use this tool versus alternatives like 'get_scholarship_details' for specific scholarship information or 'check_scholarship_eligibility' for eligibility assessment. No explicit when-not-to-use or prerequisite information is provided.

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

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

Annotations already cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), but the description adds useful context by specifying 'upcoming' events and workshops, which clarifies temporal scope beyond what annotations provide. No contradictions with annotations exist.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to parse quickly without unnecessary elaboration.

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

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

Given the tool's low complexity (simple list operation), rich annotations covering safety and behavior, and the presence of an output schema (which handles return values), the description is reasonably complete. It could improve by addressing sibling differentiation, but overall it provides adequate context 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?

Schema description coverage is 0%, but the description doesn't mention parameters at all. The schema fully documents 'limit' and 'offset' with defaults and types, so the baseline is 3 as the schema handles parameter documentation adequately without description input.

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

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

The description clearly states the verb ('List') and resource ('upcoming university events and workshops'), providing a specific purpose. However, it doesn't distinguish this tool from potential siblings like 'admin_add_event' or 'get_latest_news' that might also handle events, missing 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?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'admin_add_event' and 'get_latest_news' present, there's no indication of context, prerequisites, or exclusions for selecting this tool.

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

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

Annotations indicate this is a non-readOnly, non-destructive, non-idempotent, open-world operation. The description adds value by clarifying it's for 'auditing purposes,' which implies persistence and record-keeping, but doesn't elaborate on side effects, rate limits, or authentication needs beyond what annotations cover.

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

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

The description is a single, clear sentence that efficiently conveys the tool's purpose without unnecessary words. It's front-loaded and wastes no space, 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 moderate complexity (3 parameters, annotations provided, output schema exists), the description is somewhat complete but lacks details on parameter usage and behavioral context. The presence of an output schema means return values don't need explanation, but more guidance on when and how to use the tool 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%, but the description doesn't explain parameters like 'agent_id', 'tool', or 'details'. It relies on the schema's titles and types, providing no additional semantic context. With three required parameters and no schema descriptions, the baseline is 3 as the description doesn't compensate for the coverage gap.

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

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

The description clearly states the action ('Log') and purpose ('for auditing purposes'), specifying it's for AI agent interactions. It distinguishes from siblings by focusing on logging rather than administrative or query operations, though it doesn't explicitly contrast with similar tools since none exist in the sibling list.

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

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

The description provides minimal guidance, stating only the general purpose ('for auditing purposes') without specifying when to use it versus alternatives, prerequisites, or exclusions. No explicit alternatives are mentioned, and the context is implied rather than detailed.

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

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

Annotations provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds context beyond this: it specifies the tool shows 'all collected data' and is for 'approval', clarifying behavioral scope without contradicting annotations. No contradiction is present.

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 that are front-loaded with the core purpose. Every word adds value, with no redundancy or fluff, making it highly efficient and well-structured.

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

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

Given the tool's low complexity (1 parameter), rich annotations covering safety and idempotency, and no output schema, the description provides sufficient context for a preview operation. It could improve by detailing output format or error cases, but it's largely complete for its 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?

With 0% schema description coverage and 1 parameter, the description doesn't mention the 'application_id' parameter explicitly. However, it implies parameter usage by referring to 'filled admission form', which likely requires an application ID. Since there's only one parameter and the context is clear, it compensates adequately, scoring above the baseline.

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

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

The description clearly states the verb 'preview' and the resource 'filled admission form', specifying it shows 'all collected data for approval'. It distinguishes from siblings like 'confirm_and_submit_admission_form' (submission) and 'get_admission_form_status' (status check), but doesn't explicitly contrast them, keeping it at 4.

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 ('before submission', 'for approval'), suggesting it's used to review data prior to finalizing. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_admission_form_status' or prerequisites, leaving some ambiguity.

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

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

Annotations already provide comprehensive behavioral hints (read-only, non-destructive, idempotent, closed-world). The description adds minimal context about search scope (name or code) but doesn't disclose additional behavioral traits like pagination behavior, rate limits, or authentication requirements. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that immediately conveys the core functionality without any unnecessary words. It's perfectly front-loaded and wastes no 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 the tool's simple search functionality, comprehensive annotations covering safety and behavior, and the presence of an output schema (which handles return value documentation), the description is reasonably complete. The main gap is lack of usage guidance relative to sibling tools.

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

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

With 0% schema description coverage, the schema provides no parameter descriptions. The description mentions 'by name or code' which partially explains the 'query' parameter's purpose, but doesn't address 'limit' or 'offset' parameters at all. This provides some value but doesn't fully compensate for the schema coverage gap.

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

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

The description clearly states the action ('Search for courses') and the searchable attributes ('by name or code'), making the purpose immediately understandable. However, it doesn't differentiate this from potential sibling search tools like 'search_faculty' or 'search_library_books' beyond specifying the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, appropriate contexts, or what distinguishes it from other search tools in the sibling list like 'search_faculty' or 'search_library_books'.

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

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

Annotations already provide key behavioral traits: read-only, non-destructive, idempotent, and closed-world. The description adds no additional behavioral context beyond what annotations cover (e.g., no rate limits, authentication needs, or result format details). However, it doesn't contradict annotations, so it meets the lower bar with annotations present.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose and includes essential details (search criteria). Every part of the 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 low complexity (search operation), rich annotations (covering safety and behavior), and the presence of an output schema (which handles return values), the description is reasonably complete. It specifies the resource and search fields, though it could benefit from more parameter guidance given the 0% schema coverage.

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%, but the description mentions search criteria ('by name or research interest'), which partially explains the 'query' parameter. However, it doesn't clarify the semantics of 'limit' or 'offset' (e.g., pagination behavior). With 0% coverage, the description adds some value but doesn't fully compensate for the schema gap.

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

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

The description clearly states the verb ('Search') and resource ('faculty members'), specifying search criteria ('by name or research interest'). It distinguishes from most siblings (e.g., 'search_courses', 'search_library_books') by focusing on faculty, but doesn't explicitly differentiate from potential faculty-related tools like 'admin_add_faculty'.

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

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

No guidance on when to use this tool versus alternatives is provided. The description doesn't mention when to prefer this over other search tools (e.g., 'search_courses') or when to use it versus administrative tools like 'admin_add_faculty'. It only states what it does, not when it's appropriate.

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

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

Annotations already provide strong behavioral hints (readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=false). The description adds minimal context beyond this—it implies a search operation but doesn't disclose details like result format, pagination behavior (though limit/offset parameters exist), or error conditions. With annotations covering safety and idempotency, the description meets baseline expectations without adding rich behavioral context.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part ('Search for books in the university library by title, author, or ISBN') directly contributes to understanding the tool's function, making it appropriately concise and well-structured.

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