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

No annotations provided; description mentions checking but does not disclose return format, side effects, or error behavior beyond the name.

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

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

Single sentence, concise, and front-loaded with no wasted words.

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

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

For a simple diagnostic tool with no parameters and an output schema, the description provides adequate context, though it could mention typical usage.

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

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

No parameters; schema coverage is 100%; baseline score applies as description adds no parameter 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 checks credential configuration and session creation ability, distinguishing it from siblings like refresh_session.

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

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

No explicit when-to-use or when-not-to-use guidance; usage is implied but not stated, e.g., use before other operations.

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

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

With no annotations, the description must fully disclose behavior. It states it inventories pages and downloads but does not specify that it is read-only, whether it recursively traverses, or any other traits like auth requirements or potential performance impact.

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

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

The description is a single sentence with no extraneous content. It is front-loaded with the core action and object, earning its place.

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

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

Given four parameters, an output schema, and moderate complexity, the minimal description is insufficient. It lacks details on recursive behavior, limits, and output format, which the output schema alone may not fully convey for selection.

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 add meaning. It mentions pages and downloadable resources, which relates to include_downloads, but fails to explain max_depth, max_pages, or course_url format. Two of four parameters are effectively undocumented.

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 'Inventory pages and downloadable resources inside a Ninova course tree' uses a specific verb (inventory) and clearly identifies the resource. It distinguishes from sibling tools like read_page and download_resource by indicating a broader scope (crawling the whole tree).

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

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

No guidance is given on when to use this tool vs alternatives like get_course_sections or get_course_lesson_files. There is no mention of prerequisites, context, or exclusions, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries full burden. It states a comparison but omits side effects (likely read-only), error conditions (no snapshot found), or output format. The presence of an output schema mitigates some gaps.

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

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

The description is a single, concise sentence that front-loads the key purpose. No unnecessary words, but could be slightly more informative without losing conciseness.

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

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

Given the tool has 3 parameters and no schema descriptions, the description is too sparse. It lacks context on how to specify a snapshot (label vs path) and fails to set expectations about required prior actions. Output schema covers return values but not usage flow.

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 must explain parameters. It fails to define what 'url', 'label', or 'snapshot_path' mean or how they interact, leaving the agent to guess.

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

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

The description clearly identifies the action (compare) and the resources (current state vs stored snapshot), distinguishing it from sibling tools like snapshot_page and read_page. However, it does not specify the nature of the diff output.

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

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

No guidance is given on when to use this tool versus alternatives, prerequisites (e.g., must have a prior snapshot), or when not to use it. Sibling tools exist but are not differentiated.

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

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

No annotations are provided, so the description carries full burden. It mentions downloading to disk but does not disclose authentication requirements, file overwrite behavior, size limits, or any side effects.

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

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

The description is a single concise sentence with no waste, front-loaded with the verb 'Download'.

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

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

With 3 parameters, 0% schema coverage, and an output schema not shown, the description fails to provide enough detail for an agent to use the tool correctly. It lacks parameter explanations and behavioral context.

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

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

Schema description coverage is 0%, and the description adds no meaning to the three parameters (url, filename, output_dir). It does not explain what each parameter does or how to use them.

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

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

The description clearly states the action (download), resource (Ninova file or authenticated resource), and destination (to disk). It is specific and distinguishes from siblings like read_page or crawl_course which do not involve downloading to disk.

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

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

The description implies usage for downloading files but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives like crawl_course for other resource types.

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

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

No annotations are provided, so the description bears full burden. It correctly indicates a read operation but does not explicitly state it is read-only or disclose other behavioral traits like rate limits or data freshness. The simplicity of the tool mitigates the gap.

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

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

The description is a single sentence, which is concise but at the cost of necessary detail. It lacks explanations for parameters and usage, making it less helpful than it could be.

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 presence of an output schema, return values need not be explained, but the description fails to cover the three parameters adequately. It does not mention optional parameters or defaults, leaving gaps for a tool with moderate 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 should explain parameter meanings. It does not mention 'limit', 'course', or 'include_full_text' at all, leaving the agent to infer from names alone, which is insufficient.

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 ('return announcements') and the target ('a specific Ninova course'), with a specific verb and resource, distinguishing it from sibling tools like get_course_info or get_course_grades.

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 is no mention of prerequisites, conditions, or exclusions, leaving the agent to infer usage from context.

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

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

No annotations are provided, so the description carries the full burden. It only states the basic operation without disclosing any behavioral traits such as read-only nature, pagination, permission requirements, or performance implications.

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

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

The description is a single sentence that is front-loaded and concise. However, it could be slightly longer to add needed details without sacrificing conciseness.

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

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

Given the tool has an output schema and two parameters, the description is too brief. It does not explain the output format or the role of 'limit', making it incomplete for agents to use correctly.

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

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

With 0% schema description coverage, the description should explain parameters, but it does not. The 'limit' and 'course' parameters are not described, leaving the agent to infer their meaning from the schema structure alone.

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

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

The description clearly states it returns a course's assignment list with full details. It distinguishes from siblings like get_course_grades or get_course_info, but does not explain the scope compared to get_dashboard_assignments.

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. The description lacks context about prerequisites or when not to use it, which is important given many sibling tools for course data.

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

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

No annotations are provided, so the description carries the full burden. It states 'Read', implying a non-destructive operation, but it does not disclose any other behavioral traits such as authentication requirements, rate limits, or what happens if the page is inaccessible. The output schema exists but is not detailed in the description.

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 very concise (one sentence) and front-loaded with the key action and resource. However, it is so brief that it omits important context, making it insufficiently informative.

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 (one parameter, no annotations, 0% schema coverage), the description is incomplete. It lacks usage guidelines, parameter details, and behavioral transparency. The presence of an output schema somewhat mitigates the need to describe return values, but other gaps remain.

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 does not explain the 'course' parameter. It does not specify the expected format (e.g., course ID, course code) or any constraints. The description adds no meaning beyond the parameter name.

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

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

The description uses a specific verb 'Read' and identifies a clear resource: the Ninova 'Yoklama' page for a course. The tool name 'get_course_attendance' reinforces the purpose, and it is distinguishable from siblings like 'get_course_grades' or 'get_course_assignments'. However, the description does not explicitly differentiate from siblings beyond the name.

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

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

No usage guidelines are provided. The description does not specify when to use this tool versus alternatives like 'get_course_overview' or 'get_upcoming_deadlines'. There is no mention of prerequisites or typical use cases.

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

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

With no annotations provided, the description carries full burden. It does not disclose if the operation is read-only, required authentication, or any side effects. Only states it lists files, missing 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 concise at one sentence and front-loaded with the action. However, it sacrifices informativeness for brevity; a bit more detail would improve it.

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?

Although an output schema exists, the description lacks context for parameters, usage boundaries, and behavioral traits. For a tool with 3 parameters and no schema descriptions, this is insufficient.

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 adds no parameter-specific details. The parameters 'course', 'max_depth', and 'recursive' are not explained; the description does not clarify their meaning, format, or 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 'List files and folders under the Ninova 'Sınıf Dosyaları' section for a course.' It specifies the verb 'list' and the exact resource, distinguishing it from sibling tools like get_course_lesson_files.

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, nor does it mention prerequisites, limitations, or exclusions. There is no contextual information to help the agent decide between this and 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?

No annotations provided. Description only says 'Read', implying read-only, but lacks details on authentication, rate limits, or what the page contains. The agent has no insight into behavior beyond that.

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

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

Single sentence with no extraneous words. Front-loaded with verb and resource. Every part 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 an output schema exists and the operation is simple (reading a page), the description is nearly sufficient. It could mention that it retrieves grades specifically, but the tool name implies that. Context is adequate.

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

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

With 0% schema description coverage, the description adds 'for a course' to the single parameter, providing context that the course identifier is needed. No format or source is specified, but it's minimally informative.

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

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

Description clearly states verb 'Read' and resource 'Ninova 'Notlar' page for a course', making it specific and distinct from sibling tools like get_course_assignments or get_course_attendance.

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; it only says 'for a course', but doesn't mention prerequisites, when not to use, or how it compares to other get_course_* 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 are absent, so the description must cover behavioral traits. It only implies a read operation ('Return structured information'), but lacks details on side effects, auth requirements, or performance implications.

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

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

The description is a single sentence, but it is under-specified—missing crucial details that a longer description could provide without adding excessive length.

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

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

Despite having an output schema, the description does not explain what the returned structured information contains. Given the many sibling tools, the lack of differentiation and parameter details makes it incomplete.

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 single 'course' parameter has no description in the schema (0% coverage) and the tool description adds no guidance on its format or allowed values.

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

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

The description clearly states it returns structured information from a specific page ('Sınıf Bilgileri'). However, it does not differentiate this from other 'get_course_*' siblings, which also return structured data from other pages.

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. There is no mention of prerequisites, when-not-to-use, or comparison with 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?

No annotations provided, so description carries burden. It correctly indicates a read operation (list) with no mention of side effects, but lacks details on authorization, rate limits, or output structure. Adequate but minimal.

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

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

Single concise sentence front-loaded with action verb. No unnecessary words.

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

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

Despite having an output schema, the description lacks essential context for a 3-parameter tool. It does not explain the Ninova domain, the meaning of 'Ders Dosyaları', or how parameters affect behavior. Incomplete for effective 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 coverage is 0%, yet description provides no parameter explanations. Parameters like course, max_depth, and recursive are not described, leaving the agent without semantic context beyond their names.

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

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

Description clearly states verb 'List' and specific resource 'files and folders under the Ninova 'Ders Dosyaları' section for a course.' This distinguishes it from sibling tools like get_course_class_files, which likely target a different section.

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 (e.g., get_course_class_files). The description only states what it does without usage context or conditions.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Read,' but lacks information on rate limits, required permissions (e.g., course enrollment), pagination, or error behavior. This is inadequate for a tool with three parameters.

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

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

The description is a single sentence with no wasted words. However, it sacrifices necessary detail for brevity, so it is not ideally structured for clarity.

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

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

Given three parameters with zero schema coverage and no annotations, the description is too minimal. An output schema exists, but an agent still needs parameter context and usage details to invoke this tool correctly.

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

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

Schema description coverage is 0%, so the description should compensate by explaining parameters like 'limit' and 'include_thread_details.' It does not; only the field names are given, adding no semantic value.

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

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

The description clearly states the verb 'Read' and the specific resource 'Ninova 'Mesaj Panosu' page for a course.' This distinguishes it from sibling tools like get_course_announcements, but it could be more precise about the content type (e.g., messages, threads).

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, nor any prerequisites or scenarios where it should not be used. The description only states what it does.

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

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

No annotations are present, and the description only lists what data is returned without disclosing behavioral traits such as whether the operation is read-only, if it triggers network requests, performance implications, or error handling. The refresh and file_max_depth parameters are not explained.

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

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

The description is a single sentence that efficiently communicates the tool's output. It is front-loaded with the main purpose. However, it could be slightly more concise by removing 'remote learning routes' if it's not a standard term, but overall it is 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?

Despite having an output schema, the description lacks context on parameter behavior, error conditions, and use cases. Given the tool aggregates many sub-resources, agents would benefit from knowing that it may be slow or require specific permissions. The description is not complete enough for confident invocation.

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 three parameters with 0% description coverage. The tool description adds no meaning to the parameters; it does not explain the purpose of 'refresh', 'file_max_depth', or the 'course' identifier. With low coverage, the description fails to compensate, leaving the agent without crucial usage 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 that the tool returns a combined view of a course, listing multiple components like sections, announcements, assignments, files, etc. This differentiates it from sibling tools that focus on individual aspects, making its purpose unmistakable.

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

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

The description implies usage for obtaining a summary of multiple course components, but it lacks explicit guidance on when to prefer this tool over the specific sibling tools (e.g., get_course_announcements). No when-not or alternative recommendations are provided.

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

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

The description implies a read-only operation but does not disclose additional behavioral traits such as return format, authentication requirements, or pagination. No annotations are present to compensate.

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 very concise (one sentence), but it is not front-loaded with key information. It could be more efficient while still being informative.

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?

While the tool has an output schema, the description lacks essential context such as what the page contains, any prerequisites, or differentiation from other tools. Incomplete for a tool with 25 siblings.

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

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

The parameter 'course' is only implicitly mentioned in the description ('for a course'), adding no meaning beyond the parameter name. Schema coverage is 0%, so the description should provide more context.

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

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

The description clearly states it reads a specific page ('Uzaktan Eğitim') for a course, which is distinct from other course tools. However, it could be more specific about what this page contains.

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

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

No guidance on when to use this tool versus alternatives like get_course_info or get_course_sections. With many similar siblings, explicit differentiation is missing.

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

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

With no annotations, the description must disclose behavior. It correctly implies a read-only operation ('Return all courses'), but does not mention caching, authentication requirements, or potential performance impacts. However, the tool has no parameters and an output schema, so the description is minimally adequate.

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 extraneous information. Every word contributes to understanding 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 no annotations but an output schema, the description is sufficient for a simple list operation. However, it lacks context about the source (live vs cached), scope ('visible' may need clarification), and does not differentiate from sibling tools that might also list courses.

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

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

The tool has zero parameters, and schema description coverage is 100%. The description adds no parameter information because none is needed. Per guidelines, 0 parameters warrants a baseline of 4.

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

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

The description uses the specific verb 'Return' and defines the resource as 'all courses visible in the Ninova dashboard', which clearly identifies the tool's function and distinguishes it from sibling tools like 'list_courses' or 'get_dashboard'.

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. Given the presence of many sibling tools (e.g., 'list_courses', 'get_dashboard'), the agent lacks context to make an informed choice.

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

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

No annotations are provided, and the description does not disclose behavioral traits like read-only nature, authentication requirements, or side effects. It only states it lists routes, leaving important behavioral context unaddressed.

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. However, it could benefit from additional structure or clarification without becoming verbose.

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 presence of many sibling tools and an output schema, the description lacks completeness. It does not explain what 'direct course routes' entails or describe the output shape, limiting the agent's ability to use the tool effectively.

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

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

Schema description coverage is 0%, meaning the description adds no meaning to the single 'course' parameter. The schema defines it as a required string, but without any context about expected format or values, 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 uses a specific verb ('List') and resource ('direct course routes exposed on the Ninova course home page'), clearly distinguishing it from sibling tools that retrieve other course data like grades or announcements. However, the term 'direct course routes' is slightly vague.

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 siblings such as get_course_overview or get_course_info. The description does not mention prerequisites, context, or alternatives.

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

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

No annotations are provided, so the description must convey behavioral traits. It states 'Read' indicating read-only, but does not disclose any side effects, authentication needs, or data aggregation details. The presence of an output schema helps, but more context would improve 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?

Single sentence, front-loaded with key action 'Read', and covers all major data types without extraneous words. Excellent conciseness.

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

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

Given zero parameters, an output schema, and a set of sibling tools that cover specific aspects, the description is fairly complete. It could mention that it provides an aggregated summary, but overall it provides sufficient 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?

There are no parameters, and schema description coverage is 100%. The baseline is 3 because the description adds no parameter information, which is fine since there are none.

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

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

Description uses specific verb 'Read' and resource 'Ninova dashboard', and lists the data types summarized (courses, announcements, assignments, messages). This clearly distinguishes it from sibling tools like get_dashboard_announcements which are more focused.

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

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

The description implicitly suggests using this for a general dashboard overview, but does not explicitly state when not to use it or mention alternatives. Given the clear sibling differentiation, it is still effective.

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

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

With no annotations, the description provides minimal behavioral insight. It states 'Return' implying a read operation but does not mention authentication requirements, rate limits, pagination, or any side effects.

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

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

The description is a single sentence, which is concise, but it omits crucial information about parameters and usage. It could be improved with additional context without becoming verbose.

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

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

Despite having an output schema (not shown), the description is insufficient. It does not explain the scope of the announcements, what 'aggregated' means, or how parameters affect the result. The context is incomplete for effective 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 the input schema lacks descriptions. The tool description does not mention the 'limit' or 'include_full_text' parameters at all, so it adds no meaning beyond their names and types.

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 'Return' and the resource 'announcements from the Ninova dashboard's aggregated announcements page'. It distinguishes from sibling tools like 'get_course_announcements' by specifying the dashboard context.

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

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

No guidance is given on when to use this tool versus alternatives such as 'get_course_announcements' or 'get_dashboard_assignments'. The description lacks any context for decision-making.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It states 'including full details' but does not specify what those details are, whether the tool is read-only, or how pagination or limits work. Minimal behavioral information is provided.

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

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

The description is a single concise sentence that conveys the main purpose without excess. However, it could be slightly more structured by adding parameter details or usage hints.

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

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

The tool has an output schema but the description does not complement it. 'Including full details' is vague. With no annotations explaining safety or behavior, the description leaves significant gaps in understanding 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%, and the description does not explain the 'limit' parameter. The default value and type are in the schema, but no additional semantic meaning is added. The agent cannot understand the parameter's effect from the description.

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

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

The description clearly states the tool returns assignments from the aggregated dashboard page with full details. The verb 'return' and specific resource 'Ninova dashboard's aggregated assignments page' make the purpose unambiguous and distinguish it from get_course_assignments.

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 like get_course_assignments. The description does not mention prerequisites, filters, or when not to use it.

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

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

No annotations provided, so description must cover behavior. It mentions relying on a snapshot but doesn't disclose staleness, read-only nature, or effect of the 'refresh' parameter.

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

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

One sentence, 14 words, concise. But lacks structure or additional detail that would improve clarity.

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

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

Despite having output schema, the description omits critical context: how the snapshot is used, when to refresh, and differentiation from get_course_assignments or get_dashboard_assignments.

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%. The description does not explain what 'days' or 'refresh' do, leaving the agent to infer from names only.

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

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

The description clearly states it returns assignments with upcoming deadlines, distinguishing it from siblings like get_course_assignments. However, 'based on the stored tracking snapshot' is vague.

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 siblings or prerequisites like taking a snapshot first.

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

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

The description indicates a read operation but does not disclose any behavioral traits such as auth requirements, rate limits, pagination, or what 'recent' means. With no annotations, the description should provide more 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 a single, concise sentence without fluff, but it lacks structure (e.g., bullet points) and is too brief to be fully informative.

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 3 optional parameters and existence of an output schema, the description is insufficient. It does not explain filtering behavior or return format, making it incomplete for a tool that likely queries a history log.

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 the parameters are entirely undocumented. The description does not explain 'limit', 'course', or 'entity_type' or how they affect results, leaving the agent without critical usage 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 tool reads 'stored Ninova tracking history' and returns 'recent detected changes', which identifies it as a read-only retrieval tool. It uses specific verbs and resource naming, differentiating it from sibling tools like crawl_course (which likely fetches fresh 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?

No guidance is provided on when to use this tool versus alternatives. Given the many sibling tools (e.g., get_dashboard, get_course_info), the description offers no 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?

With no annotations, the description carries the behavioral burden, and it discloses the read-only return nature, anonymity, rating scale with vote counts, optional comment retrieval, and the no-login requirement. It does not describe error behavior for unknown slugs or rate-limit/authorization edge cases, but for a straightforward read tool the visible behavior is transparent enough.

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 entire purpose fits into one front-loaded sentence, with the parenthetical rating breakdown and 'No login required' each adding genuinely useful information. There is no filler, redundancy, or repetition of the tool name or schema.

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 low-complexity read tool with an output schema, the description covers the core invocation needs: target identity, what data is returned, optional comments, and authentication. It is slightly incomplete about how to obtain the slug and what comment_limit controls, but those are minor given the schema titles and the presence of sibling search/lookup 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?

Schema description coverage is 0%, so the description must compensate; it clarifies that the slug identifies a single instructor profile and that comments are optional, reflecting include_comments. However, comment_limit is never mentioned, so one of three parameters is left unexplained, leaving a clear gap despite the partial 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 starts with a specific verb and resource — 'Return one instructor profile's anonymous student ratings' — and enumerates the rating dimensions and scale, making the tool's function unmistakable. It also distinguishes itself from sibling tools like hocametre_search_instructors and hocametre_lookup_instructors, which are about discovery rather than retrieving a single profile's ratings.

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

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

It implies the intended use is when a slug is available and the agent wants a single instructor's ratings and optional comments, and 'No login required' adds useful access context. However, it never says when not to use it or points to hocametre_search_instructors/hocametre_lookup_instructors for finding a slug, so the routing guidance is only implied.

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

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

Since no annotations are provided, the description carries the burden of behavioral disclosure. It does disclose key behaviors: returns every matching profile, sorts by vote count, and provides a vote-weighted combined score due to duplicate profiles. This adds meaningful information beyond the output schema, though it omits details like empty-result behavior or potential 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 three sentences, each adding substantive value: purpose, output behavior, and authentication need. It is front-loaded with the main action and avoids redundant phrasing, making it appropriately concise.

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

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

With an output schema present, return values are already structured, so the description need not repeat them. However, the absence of explanations for 'comment_limit' and 'include_comments', plus no guidance on alternatives to sibling tools, leaves gaps for an agent deciding how to invoke it correctly. The description is adequate for the core purpose but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It explains the 'names' parameter implicitly via 'several instructor names (as printed in the OBS schedule)', which is helpful. However, it does not mention 'comment_limit' or 'include_comments' at all, leaving two of the three parameters semantically uncovered.

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 resolves multiple instructor names to hocametre ratings, with a specific verb ('resolve') and resource ('instructor names to their hocametre ratings'). It does not explicitly differentiate from sibling tools like hocametre_search_instructors or hocametre_get_instructor, but the batch nature and the OBS schedule context make the purpose clear.

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 useful context: names should be 'as printed in the OBS schedule' and 'No login required', which signals the intended input source and authentication expectation. However, it does not mention when to choose this tool over hocametre_search_instructors or hocametre_get_instructor, nor any exclusion criteria, so alternatives are not addressed.

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

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

With no annotations, the description carries the full burden. It discloses 'No login required' and 'public OBS schedule', which are key behavioral traits. It implies a read-only operation. It does not mention rate limits, errors, or term dependence, but these are less critical for a public query tool. The disclosure of auth requirements is valuable.

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

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

The description is a single dense sentence that front-loads the core purpose and includes the key output fields and the no-login note. It is efficient but could be split for readability; still, it is not verbose and every clause adds 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?

The tool has 5 parameters with 0% schema coverage, and the description explains none of them except implicitly 'codes'. An agent would not know how to set 'level', 'comment_limit', 'only_available', or 'include_comments'. While an output schema exists, the input semantics are critically under-explained for a tool with this many parameters.

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

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

Schema description coverage is 0%, so the description must compensate. It only implicitly explains 'codes' (given course codes). It does not explain 'level', 'comment_limit', 'only_available', or 'include_comments' at all. The description adds minimal meaning beyond the parameter names, leaving the agent to guess what these parameters control.

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

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

The description states a specific verb+resource: it lists sections with schedule details and instructor hocametre ratings for given course codes. It clearly differentiates from siblings like obs_public_get_schedule (schedule only) and hocametre_get_instructor (single instructor) by combining both data sources.

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

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

It provides a clear context: use this to compare sections of the same course by instructor ratings. It does not explicitly mention alternatives or exclusions, but the purpose is sufficiently distinct that an agent can infer when to use it. Lacks explicit when-not guidance, but the context is clear.

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

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

No annotations are provided, so the description carries the burden. It explicitly discloses that the data source is public, that no login is required, and that duplicate profiles are possible, and the search/return behavior is clear. It omits rate limits or pagination details, but those are minor for a simple read-only search.

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

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

Two concise sentences with no filler. The primary action and output are front-loaded, followed by the no-login requirement and duplicate-profile caveat. Every sentence earns its place.

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

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

For a simple 2-parameter search tool with an output schema, the description covers purpose, auth requirement, duplicate caveat, and output shape. It could mention limit behavior or route to sibling tools, but the core information needed to invoke it correctly is present.

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

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

Schema descriptions are absent at 0% coverage, and the description compensates for the 'query' parameter by specifying it is a partial instructor name. However, 'limit' is not explained beyond its name and default, so parameter semantics are only partially addressed.

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 operation: search public hocametre instructor ratings by partial instructor name and return matching profiles with slugs. It is specific and informative, though it does not explicitly differentiate it from similar siblings like hocametre_lookup_instructors.

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

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

The description gives clear when-to-use context: search public ratings by partial name, no login required, and be aware of duplicate profiles. It does not name alternative tools or exclusion cases, so it stops short of a 5.

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

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

With no annotations, the description must fully disclose behavioral traits, but it only states the action without mentioning side effects, read-only nature, or dependencies like a loaded dashboard.

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, focused sentence that front-loads the core action. Every word contributes, with no redundancy.

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

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

While the tool is simple with no parameters and has an output schema, the description lacks context to differentiate from similar list tools (e.g., 'get_courses') and omits behavioral context, making it minimally viable.

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

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

The tool has zero parameters, so schema coverage is 100%. The description adds no param details, but baseline for 0 params is 4 as no additional information is needed.

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

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

The description uses a specific verb 'List' and clearly identifies the resource 'all discovered Ninova courses from the dashboard', which distinguishes it from siblings like 'get_courses' and 'sync_all_courses'.

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 such as 'get_courses' or 'get_dashboard'. The description does not mention any prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the operation is read-only and returns raw JSON, which is essential behavioral information. However, it does not mention authentication requirements, possible error responses, or whether the session must be refreshed first.

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

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

The description is a single front-loaded sentence with no filler. Every phrase earns its place: 'Read any...', 'return raw JSON', and 'read-only escape hatch' all contribute to understanding and routing.

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 one-parameter tool with an output schema, the description is reasonably complete, but the lack of annotations leaves gaps around authentication and failure behavior. An agent would benefit from knowing whether a valid OBS session is required or what happens when an endpoint is invalid.

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

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

The only parameter, 'path', has no schema description, so the description must compensate. It clarifies that the value should be an OBS API path under '/api/ogrenci/...', but it omits concrete examples, whether the base URL should be included, and whether query parameters are allowed. Partial compensation only.

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

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

The description uses a specific verb 'Read' and a clearly defined resource ('/api/ogrenci/... OBS endpoint'), and states the output is raw JSON. Calling it an 'escape hatch' distinguishes it from the dedicated, higher-level OBS tools listed among siblings.

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

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

The phrase 'escape hatch' strongly implies this tool is for cases not covered by the more specific sibling tools, giving an agent a clear selection heuristic. It does not explicitly list exclusions, but the intent is sufficiently clear from context.

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

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

With no annotations provided, the description carries the full burden. 'Check whether ... can sign in' indicates a read-only status operation and names the SSO mechanism, but it does not disclose whether the check itself requires an existing session or has side effects, such as refreshing a token.

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

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

The description is a single, front-loaded sentence with no redundancy. Every word adds meaning, and the key action ('Check') appears first.

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

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

For a zero-parameter status check with an output schema, the description captures the essential behavior. The only gap is that it does not mention prerequisites like an active session or how this relates to refresh_session, but this is a minor omission for such a simple tool.

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

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

The tool has zero parameters, so the schema already covers everything. The description adds useful context about the OBS/girisv3 SSO target, which is sufficient when no parameters exist.

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

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

The description uses a specific verb ('Check') and a precise resource ('whether the ITU account can sign in to OBS via girisv3 single sign-on'), which clearly distinguishes it from the generic auth_status sibling. The title and description align and convey exactly what the tool evaluates.

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 this is a preflight auth check for OBS operations, but it does not explicitly state when to use it over alternatives like auth_status or obs_refresh_session. No exclusions or when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds valuable details: that it expands through course-plan equivalences for renamed codes, that prerequisites reflect current programme definitions even for older plans, and the default action. However, it does not mention whether the operation is read-only, any side effects, or auth requirements. For a tool with zero annotations, this is a moderate but not exhaustive disclosure.

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

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

The description is three sentences and front-loads the purpose. It packs useful context about equivalences and default behavior without padding. It is concise and appropriately structured, though slightly dense in the middle sentence.

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 the tool (evaluating prerequisites with equivalences and defaults) and the complete lack of parameter documentation in the schema, the description is insufficient for an agent to use it correctly. The purpose and some behavioral nuances are clear, but the missing parameter semantics and lack of explicit alternatives leave significant 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 description must compensate by explaining the three parameters: codes, program, and assume_passed. The description mentions none of them, leaving their meaning and usage entirely undocumented. This is a critical gap; an agent cannot correctly call the tool without knowing what these parameters represent.

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

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

The description uses a specific verb ('Decide') and clearly identifies the resource (courses the student may register for) and the evaluation logic (prerequisite expression vs passed courses, with equivalences). It distinguishes itself from sibling tools like obs_public_get_prerequisites by emphasizing the student-specific check against their passed courses and defaulting to graduation-required courses.

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

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

The description provides a clear usage scenario: deciding which courses a student may register for, and explicitly mentions the default behavior (every course still required for graduation). However, it does not explicitly state when not to use it or name alternative tools, such as obs_public_get_prerequisites, which could be used for simply fetching prerequisites. The context is clear enough for an agent to infer typical use.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Return' signals a read operation, but it does not mention authentication requirements, session needs, or any latency/error behavior. It adds no behavioral context beyond the bare fact that data is returned.

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, short sentence with the primary action front-loaded. It is concise and readable, though 'semester-by-semester GPA' followed by 'semester GPA' is slightly redundant and could confuse.

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 that the tool has no parameters and an output schema exists, the description is reasonably complete for a simple data-retrieval operation. It names the key data categories returned, though it does not provide usage context or authentication notes.

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

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

The tool has zero parameters, so the baseline is 4. The description adds semantic context about the returned fields, which is useful even though parameter semantics are not applicable.

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

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

The description states a specific verb ('Return') and resource ('academic standing') and lists concrete output components: semester-by-semester GPA, credit, and class-level history. It is clear enough to distinguish from most sibling tools, though it does not explicitly differentiate itself from overlapping tools like obs_get_transcript.

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

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

No guidance is given about when to use this tool versus alternatives such as obs_get_transcript, obs_get_grades, or obs_get_course_history. The description simply states what it returns, leaving all selection decisions to the agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states it returns announcements, implying a read operation, but does not disclose pagination behavior, authentication requirements, or any other traits. It is minimal and does not go beyond what the name implies.

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

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

The description is a single, concise sentence with no wasted words, which is appropriately front-loaded. It is efficiently structured, though it might be under-specified for the overall task, but the structure itself is clean.

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 presence of an output schema and only two optional parameters, the tool is relatively simple, but the description is too sparse to fully contextualize its use. It does not explain when to prefer it over similar sibling tools, nor does it mention any prerequisites or expectations. The minimalism leaves the agent guessing about the scope and usage.

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

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

Schema description coverage is 0%, so the schema provides no parameter meanings, and the description does not mention the page or limit parameters at all. With two parameters and no descriptions, the tool fails to compensate for the lack of semantic guidance, making it difficult for an agent to understand how to use them.

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

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

The description clearly states the action ('Return') and resource ('announcements published in OBS'), making the purpose understandable. It distinguishes from siblings like get_course_announcements or get_dashboard_announcements by specifying 'OBS' as the source, though it does not explicitly contrast with them. This is clear but not fully differentiated.

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

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

There is no guidance on when to use this tool versus alternatives such as get_course_announcements or get_dashboard_announcements. The description is a bare statement with no contextual cues about preferred scenarios or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states that the tool returns attendance for a registered class; it does not mention authentication/session requirements, error behavior, or what 'attendance record' includes. The 'registered class' qualifier adds a small constraint, but key behavioral context is missing.

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

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

The description is a single sentence with no filler. It front-loads the action and resource, then specifies the identifier. 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?

With a single parameter and an output schema present, the tool is structurally simple and return values are already covered. However, the description omits usage guidance versus sibling tools and does not mention whether an authenticated OBS session is required, which is a notable gap for an OBS data-fetching tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly identifies the lone parameter's semantics as the 'OBS class id,' which is meaningful and differentiates it from a generic course identifier. It stops short of explaining how to obtain the id, but for a single simple parameter this is adequate.

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

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

The description uses a specific verb ('Return') and a specific resource ('the attendance record for one registered class'), scoped by 'its OBS class id.' This clearly identifies both the action and the distinguishing identifier, separating it from siblings like get_course_attendance that are not OBS-specific.

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

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

The description implies when to use the tool: when you need attendance for a single registered class and have the OBS class id. However, it does not explicitly mention alternatives or state when not to use it, leaving some routing inference to the agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation via 'Return' but does not explicitly state read-only status, authentication requirements, rate limits, or any side effects. It also does not clarify what happens when include_empty is toggled, which is a behavioral nuance.

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

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

The description is a single, tightly written sentence that front-loads the core action and outcome. There is zero fluff or redundancy, making it highly efficient.

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

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

While the description covers the main return content, it omits explanation of the include_empty parameter and does not differentiate from sibling tools. Given the tool's simplicity and the presence of an output schema, the description is still insufficient because the parameter is undocumented and usage context is absent.

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 does not mention the only parameter, include_empty. The agent has no clue what this boolean does or when to set it true or false. The description fails to compensate for the schema's lack of explanation, leaving the parameter entirely mysterious.

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

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

The description states a specific verb 'Return' with a clear resource: 'every graded course across every semester, plus pass/fail counts and the list of failed courses.' It is unambiguous about the scope and contents. However, it does not explicitly differentiate from close siblings like obs_get_transcript or obs_get_grades, so it stops short of 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 obs_get_grades or obs_get_transcript. There is no mention of context, exclusions, or prerequisites, leaving the agent to infer usage purely from the name and content.

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

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

No annotations are provided, so the description carries the full behavioral burden. It describes the returned content well: per unfilled slot, eligible pool, term offerings with CRNs/times, and prerequisite status. However, it does not disclose whether authentication is required, whether this is a read-only operation, or any rate-limit/failure behavior.

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

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

A single, dense sentence that front-loads the key scope ('every elective slot not yet filled') and then lists the exact data categories provided. There is no filler, repetition, or unnecessary preamble.

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

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

With an output schema present, the return structure is covered elsewhere. The description gives a solid high-level picture, but it is not fully self-sufficient: five parameters have no schema descriptions and no parameter-level guidance is provided in the description, and usage relative to sibling tools is not addressed.

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 for five undocumented parameters. It indirectly maps to only_offered ('run this term') and check_prerequisites ('whether the prerequisites are met'), but it never explains level, program_code, or assume_passed. An agent would have to guess the meaning or inspect external references.

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 identifies a specific resource and scenario: unfilled elective slots, eligible courses, courses offered this term with CRNs and times, and prerequisite status. It clearly differentiates itself from siblings like obs_get_elective_pool and obs_check_prerequisites by combining term offering and prerequisite checking into one elective-options query.

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

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

The description implies when the tool is useful: when a student needs their elective options for the current term and wants to see which are offered and whether prerequisites are met. However, it gives no explicit when-not-to-use guidance or alternatives, such as 'use obs_get_elective_pool for all eligible courses regardless of term.'

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

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

With no annotations provided, the description carries the behavioral burden. 'Return every course' conveys a read-only query with no destructive side effects, and 'by group id' indicates a simple parameterized lookup. However, it does not disclose authentication requirements, data freshness, or any filtering beyond the group id.

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

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

The description is a single sentence with no filler. It front-loads the tool's core behavior and scopes it to the student's course plan, making every word meaningful.

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?

Although an output schema exists to explain return values, the description is incomplete for safe invocation: the single required group_id parameter is undefined, and there is no usage context to distinguish this from similar elective-related tools. The agent is left to guess how to obtain group_id and when to prefer this tool.

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

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

Schema description coverage is 0%, so the description must compensate for the bare group_id integer field. The description only says 'by group id' and does not explain what a group id is, where the agent obtains it, or how it relates to the elective pool. This leaves the required parameter under-specified.

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 names the operation ('Return every course') and the specific resource ('courses that can fill one elective slot of the student's course plan'). It is specific enough to identify the tool's function, but it does not distinguish itself from the similarly named sibling obs_get_elective_options.

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 when-to-use guidance is provided, no alternatives are named, and no exclusions or prerequisites are mentioned. The description states what the tool does but not when an agent should select it over obs_get_elective_options or other listed course-related tools.

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

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

No annotations are present, so the description must carry the full behavioral disclosure burden. It states the tool returns data, implying a read operation, but does not disclose authentication needs, behavior when semester is null, error conditions, or whether data is live versus cached.

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 redundant wording. However, it is slightly under-specified for the semantic burden it carries, so it earns a 4 rather than a 5.

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

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

Despite the tool being simple, the description omits essential invocation context: how to supply the semester, what happens if omitted, and whether authentication is required. Output schema exists but does not compensate for missing parameter semantics and usage guidance.

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 only weakly echoes the parameter name via 'for one semester.' It does not explain the expected semester string format, acceptable values, or the meaning of null/default behavior, leaving the agent to guess.

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

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

The description uses a specific verb ('Return') and resource ('final exam dates, times, and rooms'), making the tool's purpose immediately clear. It also differentiates from sibling tools like obs_get_schedule by explicitly specifying 'final exam schedule' rather than general schedule.

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?

There is no guidance on when to use this tool versus alternatives such as obs_get_schedule or obs_public_get_schedule. The phrase 'for one semester' gives a minimal scope hint, but no explicit conditions, prerequisites, or exclusions are provided.

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

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

With no annotations provided, the description carries the full burden. It does disclose the read-only nature ('Return') and the output contents (letter grades, grade points, pass/fail flags). However, it does not explain what happens when the optional semester parameter is omitted, what format semester takes, or whether authentication is required, which are material behavioral gaps.

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

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

A single, front-loaded sentence states the core behavior and return contents with no filler. Every word earns its place.

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

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

The tool is simple and has an output schema, so the description does not need to enumerate return values. However, it is incomplete regarding the semester parameter's format and null behavior, and it does not route the agent to obs_list_semesters for valid semester identifiers.

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, so the description must compensate, but it only repeats the idea that the tool covers 'one semester.' It provides no format for the semester value, no default behavior for null, and no pointer to obs_list_semesters for valid values.

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

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

The description uses a specific verb and resource: 'Return the final letter grades for one semester, with grade points and pass/fail flags.' It clearly distinguishes this from siblings like obs_get_interim_grades by specifying 'final' grades, and from broader tools like obs_get_transcript by scoping to one semester.

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

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

The phrase 'final letter grades for one semester' implies this is for final semester grades rather than interim or cumulative results, but it never explicitly states when to use this tool versus alternatives. With siblings like obs_get_interim_grades available, naming the alternative or exclusion criteria would have strengthened this dimension.

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

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

With no annotations, the description carries the full burden, and it does disclose the core read behavior by listing what the tool returns. However, it does not mention prerequisites like an authenticated OBS session, or whether include_raw/include_courses change the response shape, so transparency is adequate but not complete.

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

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

The description is a single compact, front-loaded sentence that immediately states the tool's purpose and packed the key scope into a colon-separated list. There is no filler or redundant repetition of the tool name/title.

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?

An output schema exists, so documenting return values is less critical, but the optional parameters and OBS session dependency are undocumented. For the default no-arg call the description is usable, but for program-specific or raw-output invocations it is incomplete enough that an agent would have to guess.

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 adds no parameter-level meaning. The three parameters (program, include_raw, include_courses) are left entirely to their names/defaults, so the agent cannot know valid program values, what raw output means, or how include_courses alters the response. The description does nothing to 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 uses a specific verb ('Return') and names a concrete resource ('Mezuniyetime Ne Kaldı' / graduation progress). It then enumerates the exact contents: plan requirements, credits earned vs. required, GPA/internship requirements, completed courses, and missing courses, which clearly distinguishes it from siblings like obs_get_transcript or obs_get_academic_standing.

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 explicit when-to-use or when-not-to-use guidance and never names alternatives or exclusion conditions. The intended use is inferable from the returned content, but the agent gets no help choosing between this and related OBS tools such as obs_get_course_history or obs_get_transcript.

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

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

With no annotations, the description bears the full burden of behavioral disclosure. It says 'Return published in-term grades,' which suggests a read-only operation, but it does not explain authentication requirements, side effects, or what happens when the optional parameters are omitted. The default behavior of a null semester or course is entirely unspecified, which is a meaningful transparency gap.

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

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

The description is a single, focused sentence that front-loads the action and resource, then adds the most decision-relevant output details. Every clause earns its place, and the final clause about estimating a letter grade provides useful context without redundancy.

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

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

Although an output schema existsaine and the parameter count is low, the description leaves critical invocation context unresolved: what null parameters mean, which semester is used when none is supplied, and how this tool relates to obs_get_grades or obs_get_transcript. An agent would need external assumptions or additional tool calls to use it reliably.

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, but it only mentions 'semester' indirectly and says nothing about the 'course' parameter. It fails to explain accepted formats, optionality, defaults, or how the two parameters interact, leaving the agent to guess how to scope the request.

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

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

The description uses a specific verb ('Return published in-term grades') and clearly identifies the resource (a semester's courses) and the data included (mean, standard deviation, rank, weight). It distinguishes itself from siblings like obs_get_grades and obs_get_transcript by focusing on interim components rather than final grades.

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

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

The phrase 'enough to estimate a letter grade before it is posted' implies use during the term before final grades are available, which gives some usage context. However, it doesn't explicitly contrast with obs_get_grades or obs_get_transcript, nor does it state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation through 'Return' but does not disclose authentication requirements, data freshness, whether it reflects the currently logged-in student, or any side effects. With an output schema present, the return shape is covered, but behavioral traits beyond that are absent.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It says exactly what is needed without wasted words, which is appropriate for a zero-parameter getter.

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 params, output schema present), the description is minimally viable. However, it lacks any contextual framing – such as when a user should check internships or how this relates to other academic records – and does not compensate for the missing usage guidelines. It is adequate but not complete.

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

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

The tool has zero parameters and schema coverage is vacuously 100%, so there are no parameter semantics to explain. Per the baseline for 0-parameter tools, the description adequately handles this dimension by not adding irrelevant parameter information.

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

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

The description states a specific verb ('Return') and resource ('the student's recorded internships'), which clearly identifies the tool's function. While there are many sibling getter tools, none target internships, so no sibling differentiation is needed. The title and description align perfectly.

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, no prerequisites, and no context about what distinguishes it from other student record getters. It simply states the action, leaving the agent to infer usage from the name and siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what data is returned but does not disclose whether this is a read-only operation, whether it requires an active session, whether it can fail (e.g., if not authenticated), or any side effects. For a tool that likely requires authentication, this is a notable gap.

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

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

The description is a single, focused sentence that front-loads the purpose and lists the key data fields. There is no wasted wording, and it is appropriately sized for a zero-parameter 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 has zero parameters and an output schema exists, the description is mostly complete for a simple profile fetch. However, it does not mention authentication requirements or session dependency, which is relevant given sibling tools like obs_auth_status and obs_refresh_session. The output schema likely covers return structure, so the main gap is behavioral context around session requirements.

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

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

The tool has zero parameters, so the schema is trivially complete. The description adds value by enumerating the specific fields returned (student number, faculty, department, advisors, academic programs), which helps an agent understand what 'profile' means in this context. With no parameters, the baseline is 4, and the description meets it.

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

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

The description clearly states the tool returns a student's personal details, student number, faculty, department, advisors, and academic programs. It uses a specific verb ('Return') and resource ('student's personal details'), and the title 'Get OBS Profile' aligns. It is distinguishable from siblings like obs_get_grades or obs_get_transcript, though it doesn't explicitly name a sibling.

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

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

The description implies this is the tool to fetch a student's core profile information, but it does not explicitly state when to use it versus alternatives like obs_get_academic_standing or obs_get_registration_status. There is no mention of prerequisites (e.g., authentication) or exclusions. The context is clear enough for a basic profile lookup, but no explicit guidance is given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It conveys read-only intent via 'Return' and lists returned fields, but it does not explain what happens when the optional semester is omitted (default null), whether an authenticated OBS session is required, or how invalid semester values are handled. Basic safe-read behavior is clear, but edge-case behavior is left unspecified.

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

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

One sentence with the action, scope, and output fields; no filler or repetition. It could include more detail, but conciseness itself is excellent and the key information is front-loaded.

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

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

The tool is simple and an output schema exists, so return values need not be restated. However, the definition omits the semester format/default behavior, authentication expectations, and sibling routing, which matters given the large OBS tool family. An agent would not have enough context to reliably select or invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. The phrase 'for one semester' ascribes the semantic role of the semester parameter, but it gives no format examples, accepted values, or explanation of the null default. This is only marginal compensation over the bare schema.

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

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

The description clearly identifies a read operation: it 'return[s]' the courses the student is registered to, scoped to one semester, and specifies output fields (CRN, place, time). This distinguishes it from broad course-listing tools, but it does not explicitly contrast any sibling such as obs_get_schedule or obs_get_course_history, so it does not earn 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 offers no guidance on when to use this tool instead of obs_get_schedule, obs_get_course_history, or obs_get_registration_status. No exclusions, prerequisites, or alternative tool names are mentioned; usage is only implied by the phrase 'registered to'.

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

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

With no annotations, the description carries the behavioral disclosure burden, and it does so well by revealing that the tool aggregates renamed equivalents, offering availability, CRNs, meeting times, and prerequisite checks in one call. It does not mention auth requirements or explicitly state that it is read-only, but the get-prefix and non-mutating content make the semantics reasonably transparent.

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

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

The description is compact and front-loaded: the first sentence conveys the core behavior and the second gives the intended use. The phrase "The single call" is somewhat promotional but does not add meaningful operational guidance; overall there is no wasted detail.

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

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

While the tool is complex and has four optional parameters, the description explains none of them, and there are no annotations to fill in safety or filtering behavior. The output schema exists, but that does not help an agent choose parameter values; the description is incomplete for reliable invocation.

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 no property descriptions and the tool description adds no parameter-level meaning. An agent cannot tell how level, program_code, assume_passed, or only_eligible affect the result set; with 0% schema description coverage, 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 what the tool computes: for each course still required for graduation, which course codes satisfy it, current-term offerings with CRNs and meeting times, and prerequisite status. It distinguishes itself from sibling tools by combining graduation requirements, equivalences, offerings, and prerequisites into one planning call, though it lacks an explicit imperative verb and does not name 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 line "The single call to drive course-registration planning" gives a clear use context, implying this tool should be chosen when the agent needs a consolidated view for registration planning. It does not enumerate when to prefer more granular siblings such as obs_check_prerequisites or obs_get_schedule, so it stops short of explicit exclusion guidance.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. 'Return' and 'currently open' make this read like a safe, read-only status query, but it does not mention authentication expectations, what 'open' means, or any freshness/term caveats. For a zero-parameter getter, this is adequate but not richly transparent.

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

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

The description is a single front-loaded sentence with no filler or repetition. Every word contributes meaning: what is returned, for whom, and at what granularity.

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

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

With no parameters and an output schema available, the description does not need to explain return values or argument formatting. It is mostly complete for a simple status query, though a brief note about required student authentication would strengthen it.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is no parameter ambiguity to resolve. The description therefore does not need to add parameter-level detail; the baseline of 4 applies.

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

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

The description uses a clear verb-resource pair ('Return whether course registration is currently open') and adds scope with 'for the student, per semester.' It is unambiguous about the tool's function, but it does not explicitly differentiate itself from similar siblings like obs_public_registration_term or obs_get_registration_options.

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?

There is no guidance on when to use this tool versus alternatives. Sibling tools such as obs_public_registration_term and obs_get_registration_options cover related territory, and the description does not state prerequisites, exclusions, or the condition that should lead an agent to pick 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?

With no annotations, the description carries the burden of behavioral disclosure. It does reveal that the schedule is sorted by day and start time, which is useful, and 'Return' implies a read-only operation. However, it does not explain what happens when semester is null, whether authentication is required, or how failures are surfaced.

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

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

The description is one sentence with no filler; the core action, object, and output ordering are presented directly. Every word earns its place and the structure is appropriately front-loaded.

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

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

For a simple one-parameter read tool with an output schema, the description is nearly adequate. However, the optional semester parameter is left semantically unexplained, and the lack of any distinction from obs_public_get_schedule leaves an ambiguity an agent may need to resolve.

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 single parameter has zero schema description coverage, so the description must compensate. It only says 'for one semester,' which weakly hints at the semester parameter, but it never clarifies accepted values, the default behavior, or what a null semester means.

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

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

The description uses a specific verb ('Return') and resource ('weekly class schedule for one semester') and adds an ordering detail, so an agent can distinguish it from exam or course schedule tools. However, it does not explicitly distinguish this from the sibling obs_public_get_schedule, so it is clear but not fully differentiated.

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

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

The description gives no when-to-use or when-not-to-use guidance. It does not mention that obs_public_get_schedule may be the public alternative, nor does it specify when the optional semester parameter should be supplied.

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

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

With no annotations, the description carries the burden of behavioral disclosure. The word 'Return' suggests a read-only operation and the description names the returned contents, but it does not mention authentication requirements, error behavior, or what happens when the optional semester parameter is omitted.

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, front-loaded with the action and resource, and the parenthetical detail is useful rather than redundant. 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?

Although the tool has only one optional parameter and an output schema exists, the description still leaves key invocation details unclear: how to represent a semester, whether null means 'current semester,' and when this tool should be used over closely related sibling tools. This is a meaningful gap for correct usage.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'semester' parameter. It only says 'for one semester,' which adds minimal meaning beyond the parameter name; it does not specify accepted formats, value domains, or the behavior of the null default.

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

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

The description uses a specific verb ('Return') and names a clear resource: a one-semester academic status snapshot with class level, credits, and GPA. This mostly distinguishes it from likely siblings like transcript or academic standing, though it does not explicitly call out those 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 phrase 'for one semester' gives useful context that this is a semester-scoped query, implying it is not for cumulative standing or full transcripts. However, it provides no explicit when-to-use or when-not-to-use guidance relative to sibling tools such as obs_get_academic_standing or obs_get_transcript.

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

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

With no annotations, the description carries the burden of behavioral disclosure and does reveal a disk-write side effect and the PDF artifact. However, it does not mention authentication requirements, failure behavior, or limitations of the 'preview' transcript, leaving some behavioral uncertainty.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. It communicates the core action and artifact 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?

The core action is clear and an output schema exists, so return-value documentation is not required here. However, with no annotations and three optional parameters, the description is too thin on parameter semantics and usage context to be fully complete.

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

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

Schema description coverage is 0%, and the tool description does not explain the meaning or interaction of 'filename', 'language', or 'output_dir'. Property names and defaults provide minimal clues, but the description adds essentially no semantic value beyond them.

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

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

The description names a specific verb ('Download'), a specific resource ('official transcript preview PDF from OBS'), and an outcome ('save it to disk'). This is clearly distinct from query-style siblings like obs_get_grades or generic file tools like download_resource.

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

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

There is no guidance about when to use this tool versus alternatives, nor any mention of prerequisites such as an active OBS session or transcript availability. The description implies the use case but provides no explicit selection criteria 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?

There are no annotations, so the description carries the full burden. It does disclose the read-only nature and the output scope ('every academic semester available for this student'), but it does not mention whether an authenticated OBS session is required, how results are ordered, or possible failure modes.

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

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

A single sentence that front-loads the verb and resource, then specifies the exact output. There is no filler or redundant restatement of the title.

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

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

For a zero-parameter list tool with an output schema, the description is nearly complete: it states what is listed and for whom. The only notable gap is the lack of authentication/session context, which is minor given the tool's simplicity.

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

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

The input schema has zero properties, so there are no parameter semantics to explain. The description adds value by naming the output fields, which is the only meaningful semantic information an agent needs.

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

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

The description uses a specific verb and resource: 'List every academic semester available for this student' and explicitly names the returned fields ('internal semester id and term code'). It is clearly distinguishable from sibling tools like list_courses or obs_get_semester_status.

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

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

No guidance is given about when to use this tool versus alternatives, nor any exclusions or prerequisites. With many semester-related siblings, an agent gets no help deciding if this is the right tool before fetching semester-specific data.

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

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

With no annotations, the description carries the full burden and meets it by disclosing nontrivial behavior: only the last attempt of a course counts, equivalent course codes are treated as the same course, and the tool self-checks against the GPA reported by OBS to expose silent model drift.

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

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

Two compact sentences earn their place: purpose plus example in the first sentence, modeling rules and output behavior in the second. No redundant phrasing or filler.

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

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

The tool is low in complexity with one optional parameter and an output schema present, so the description need not explain return values. It covers input format, computation rules, and drift-check behavior; only explicit usage boundaries are missing.

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

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

Schema coverage is 0%, so the description compensates by showing the exact 'COURSECODE:GRADE' shape via the example. It does not spell out accepted grade values or null behavior in detail, but the single optional parameter is made sufficiently concrete for an agent to call the tool correctly.

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

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

The description opens with a specific verb+resource: 'Project the cumulative GPA under hypothetical grades,' which clearly identifies this as a simulation tool rather than a retrieval tool like obs_get_grades or obs_get_transcript. The concrete example input makes the operation unmistakable.

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

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

It clearly frames when to use the tool: for hypothetical grade scenarios rather than actual GPA retrieval, and it even provides an example input. It does not explicitly name sibling alternatives or state exclusions, but the context is strong enough for an agent to route correctly.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It usefully states that no login is required and clarifies what 'active' means by contrasting with registration's current term. However, it does not explain potential behaviors around the level parameter, whether the result can be empty, or how stable 'usually' is.

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

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

Two sentences with no filler. The first sentence states the action and result; the second adds a key caveat and auth hint. Information is front-loaded and every sentence earns its place.

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

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

For a simple one-parameter public lookup, the description covers purpose, auth, and category distinction, and an output schema exists. The significant missing piece is the unexplained 'level' parameter, which prevents the definition from being fully self-sufficient.

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

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

The input schema has one optional parameter, 'level', with default 'LS', and 0% schema description coverage. The description never mentions this parameter, so an agent cannot know what values are valid, whether it changes the returned term, or what 'LS' means.

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

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

The description states a specific verb and resource: 'Return the term whose course schedule is currently published on the public OBS pages, with its term code.' It also distinguishes itself from the registration-current term, which separates it from the sibling tool obs_public_registration_term.

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

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

The description gives clear context: it is for the publicly published schedule term, usually the upcoming term, and explicitly says no login is required. It does not name an alternative tool or explicitly state 'use this when…', so it falls just short of full usage guidance.

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

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

There are no annotations, so the description must carry the behavioral burden. It does disclose that the tool checks for conflicts and returns a timetable, and it explains the selection format including the optional CRN. However, it does not mention auth requirements, side effects, failure behavior, or how conflicts are represented, leaving meaningful gaps.

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

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

The description is two sentences long, with the core purpose and output front-loaded in the first sentence and the key selection-format detail in the second. Every word adds information and no space is wasted on repetition of the title or schema.

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

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

The presence of an output schema reduces the need to explain return values, and the description covers the main selection semantics. Still, with no annotations and an unexplained 'level' parameter, an agent may not have enough context to use the tool correctly in all cases. The definition is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real value for the selections parameter by defining each item as {code, crn} and explaining when CRN can be omitted. However, the 'level' parameter is not explained beyond its default value 'LS', so one of two parameters remains semantically under-specified.

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

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

The description clearly states the tool's function: 'Check a candidate set of sections for time clashes' and explicitly states the return value: 'return the resulting weekly timetable.' This is specific about the verb, resource, and output, and it is clearly distinct from sibling schedule-retrieval tools.

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

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

Describing the input as a 'candidate set of sections' clearly indicates this tool is for hypothetical schedule checking, not for retrieving an actual registered schedule. It does not name alternatives or provide explicit 'when not to use' guidance, so it stops short of a 5.

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

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

With no annotations, the description carries the disclosure burden. It does communicate that the operation is public and that only published sections are returned, which is useful. However, it does not mention rate limits, error behavior, pagination, or the effect of the only_available flag.

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

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

A single front-loaded sentence communicates the core action, batching nature, return scope, and public-access trait with no filler. Every clause adds value and the description is easy to scan.

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

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

Although an output schema exists, the input semantics are under-specified: an agent cannot tell what 'level' means or how 'only_available' changes results. The lack of any parameter descriptions plus missing usage guidance leaves the definition incomplete for a three-parameter public API.

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 explain the parameters. It clarifies what 'codes' means but leaves 'level' and 'only_available' completely unexplained, despite both having meaningful defaults that are not self-evident.

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

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

The description states a specific action ('look up'), a specific resource ('courses by code'), and the expected result ('return their published sections'). The batch qualifier and public scope distinguish it from list-like siblings, though it does not explicitly name an alternative tool.

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

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

The only usage signal is 'No login required,' which implies this is for public lookups. There is no explicit guidance on when to use this tool versus siblings like get_course_sections, obs_public_list_plans, or list_courses, and no exclusion criteria are given.

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

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

No annotations are present, so the description carries the full disclosure burden. It does disclose that no login is required and implies a read-only lookup, but it does not describe response behavior, empty results, pagination, or error conditions. For a simple public get this is adequate but not rich.

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

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

The description is two terse sentences with no filler. The core purpose is front-loaded, and the second sentence adds valuable context about cohort reconciliation and authentication.

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?

Although an output schema exists, the tool still has four parameters with no schema-level descriptions and no annotations. The description does not explain what program or plan_type_id mean or how required values should be formatted, leaving significant room for misinvocation.

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 the plan and branch role, but leaves program and plan_type_id undocumented, does not clarify the default of plan_type_id, and gives no value-format guidance for required 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 states a specific verb (Return), resource (course equivalences for a plan and branch), and contextual purpose (reconciling renamed course codes). This clearly separates it from sibling tools such as obs_public_get_prerequisites or obs_public_list_plans.

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 offers a useful context clue—how renamed course codes are reconciled across cohorts—but does not explicitly state when to use this tool versus alternatives. There is no exclusion guidance or mention of when another public tool should be preferred.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds meaningful context: the tool is public, requires no login, and returns current programme-defined prerequisites rather than plan-specific data. It does not mention error conditions or rate limits, but for a simple public getter this is adequate.

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

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

Two front-loaded sentences with no filler. The first sentence states the exact output and scope; the second adds valuable nuances about current definitions and authentication. 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 one-parameter public getter with an output schema, this is mostly self-contained: purpose, scope, and auth are clear. The main gap is the branch parameter format, and the description does not explicitly route agents to public branch-listing tools or the plan-specific alternative. Usable, but not fully complete.

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

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

The description only refers to 'a branch' in passing, giving minimal meaning to the branch parameter. It does not specify whether branch expects a code, name, or ID, nor does it point to obs_public_list_branches for valid values. With 0% schema description coverage, this is not enough 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 opens with a specific verb and resource: 'Return the published prerequisite expression and minimum completed credits for every course in a branch.' It clearly distinguishes itself from plan-specific tools by stating 'not any one course plan,' which separates it from siblings like obs_check_prerequisites.

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

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

The description gives clear context: it is for published, branch-wide prerequisite definitions, requires no login, and explicitly excludes course-plan-specific views. It does not name the alternative tools explicitly, but the 'not any one course plan' phrase provides a useful when-not condition.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It usefully discloses that no login is required and that this is a public read-only lookup, but it does not describe how the optional filters (day, level, instructor, course_code, only_available) affect the result set, nor what happens with empty results or invalid branches.

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

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

The description is one efficient sentence with the main action front-loaded, concrete output fields, and an authentication note. There is no filler or redundant restatement of the title.

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 six parameters, zero schema descriptions, and no annotations, the description is incomplete for reliable invocation. It does not explain the filter parameters, the default level behavior, or how to obtain a valid branch value, although the output schema may cover return-structure details.

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 for undocumented parameters. It only clarifies the required branch parameter via 'for a course branch'; the five optional filter parameters are left entirely to the agent to infer from their names and defaults.

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?

Clearly states a specific action: return every published section for a course branch, and enumerates the expected fields (CRN, meeting days/times, instructor, room, quota, remaining seats). 'No login required' also helps distinguish it from authenticated schedule tools such as obs_get_schedule.

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 'No login required' note gives clear context for when to use this public endpoint versus authenticated schedule tools. However, it does not explicitly name an alternative or state when not to use it, such as when an individual user's enrolled schedule is needed.

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

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

With no annotations, the description carries the full disclosure burden, and it usefully states 'No login required,' which is a behavioral fact beyond the schema. The phrasing 'List' and 'published' also implies a read-only, public operation, though side effects and error behavior are not explicitly discussed.

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

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

Two short sentences deliver the core purpose, scope, examples, and auth requirement with no filler. The key action and scope appear first, making the definition easy to scan.

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

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

The tool is simple and the output schema covers return values, so the description does not need to explain those. However, the missing explanation of valid program-level values and the lack of any sibling routing leaves a noticeable gap for correct invocation beyond the default.

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 only loosely maps the 'level' parameter to 'program level,' without explaining allowed values or what the default 'LS' means. Because the schema provides no enum or property description, the description needed to compensate more and does not.

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

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

The description uses a specific verb-object pair ('List every course branch code') and gives concrete examples (BLG, YZV, MAT) plus a scope qualifier ('published for a program level'). It is easily distinguishable from sibling tools such as obs_public_list_plans and list_courses.

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

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

The description clearly scopes the operation to retrieving branch codes for a program level and states that no login is required, which signals when to use it over authentication-gated siblings. It does not explicitly name alternatives or exclusion cases, but the intended context is clear.

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

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

With no annotations, the description carries the transparency burden. It discloses that the endpoint is public ('No login required') and scoped to published plans, which is useful. It does not address behavior such as whether plan_type_id affects filtering or any error/rate-limit behavior, but the read-only nature is obvious from 'List'.

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

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

The description is a single sentence that front-loads the core action and result, with the access note appended. No filler or redundancy.

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

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

For a two-parameter public list tool with an output schema, the description covers the main purpose and access requirement. However, it leaves `plan_type_id` unexplained and does not specify how `program` should be passed (name/code), so an agent may need to infer valid input. The gaps are modest given low complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It only connects the `program` parameter to 'programme' and gives no detail about the program identifier format or what `plan_type_id` means or what valid values are. Thus it adds little beyond the schema's titles and default.

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

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

The description uses a specific verb ('List') and a specific resource ('course plans published for a programme') and states the returned identifier ('plan ids'). This distinguishes it from siblings like list_courses or obs_public_list_branches, and the 'No login required' note separates it from authenticated OBS 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 gives no explicit when-to-use guidance or alternatives. It implies a use case (someone needs published course plan IDs for a programme) and notes no login is required, but it does not explain how to choose this over sibling list tools or when not to use it.

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