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

Annotations already disclose readOnlyHint and openWorldHint; the description adds useful non-redundant behavior: it performs an HTTP GET, returns raw JSON, and auto-inserts the API version for /lp/ and /le/ paths. There is no contradiction with the readOnlyHint annotation.

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 wasted words. The escape-hatch role is front-loaded, and every clause adds useful information: raw JSON, version auto-insertion, and the full-path alternative.

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

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

For a single-parameter generic GET tool with readOnly/openWorld annotations and no output schema, the description fully covers the input format, path-version behavior, and return type. The explicit 'return raw JSON' statement compensates for the missing output schema.

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

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

There is only one parameter and schema description coverage is 0%, so the description must carry the burden. It defines path as a Valence API path, explains the difference between /lp/ and /le/ shorter forms versus the full /d2l/api/ form, and gives a concrete example. This goes well beyond the schema's pattern.

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 label 'Escape hatch' plus 'GET any Brightspace Valence API path and return raw JSON' clearly states the generic purpose and distinguishes it from the fifteen specialized sibling tools.

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

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

The term 'Escape hatch' implies use when no dedicated sibling tool covers the needed endpoint, and 'any ... path' reinforces that fallback role. However, it never explicitly says to prefer specialized tools or names a specific alternative 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, which cover the safety profile. The description adds that the tool checks session validity and reports the logged-in user, but it does not describe failure behavior, return formatting, or whether network calls are made. Some value is added, but the description does not carry substantial extra behavioral 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, compact sentence that is front-loaded with the verb and resource and gives the two key outputs. There is no wasted wording or repetition of schema information.

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

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

For a zero-parameter, read-only status tool, the description is sufficient to understand the tool's purpose and likely output. It does not specify the exact return structure, but the absence of an output schema and the simplicity of the tool make that less critical.

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

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

The tool has zero parameters and schema description coverage is 100%, so the input schema is complete. With no parameters to describe, the description correctly focuses on behavior instead of parameter details.

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

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

The description clearly states the specific action (check) and the resource (NYU Brightspace session), and explicitly identifies what the tool reports (session health and current user). This is distinct from sibling tools like login or course getters.

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

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

The description implies the tool should be used to verify that the session is valid and identify the logged-in user, but it does not explicitly state when to use it versus alternatives like login, or give conditions for use. Context is clear but no exclusions or routing guidance 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?

Annotations already declare readOnlyHint=falseepa and openWorldHint=true, so the agent expects side effects. The description adds that the tool writes files locally, but it does not disclose important behavioral details such as whether existing files are overwritten, whether directories are created, or what happens on failure. It adds some value but not a full behavioral picture.

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 tight, front-loaded sentence states the action and then cleanly enumerates the two supported source types. There is no filler, and every phrase contributes to the agent's decision-making.

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 5-parameter download tool, the description gives the critical selection logic and the provenance of fileId, and the schema covers the target directory default and course format. It does not mention authentication requirements or the return value, but no output schema exists and the primary invocation patterns are sufficiently covered.

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

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

The schema only documents dir and course (40% coverage), while topicId, assignmentId, and fileId are bare integer fields. The description compensates by grouping them into two meaningful invocation modes and by establishing that fileId is obtained from get_assignment. This adds semantic meaning beyond the raw schema, though not every parameter relationship is fully elaborated.

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: 'Save a file locally' and then disambiguates exactly which source payloads count: a content topic (topicId) or an assignment attachment (assignmentId + fileId). This clearly distinguishes it from sibling content-reading tools like get_content, read_content, and search_content.

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

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

It gives explicit conditions for choosing between the two valid invocation modes: use topicId for content topics, or assignmentId + fileId for assignment attachments. It also tells the agent where fileId comes from ('from get_assignment'). It does not explicitly state when not to use the tool or compare it to an alternative download tool, 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 readOnlyHint and openWorldHint already provided by annotations, the description adds meaningful behavioral details: results are ordered newest first, returned as Markdown, and scoped to current courses when no course filter is supplied. This goes beyond the annotations and helps the agent predict the output shape.

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 short, front-loaded sentence with no filler. It packs the core facts—resource, ordering, output format, and scoping rule—into minimal text, earning every word.

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

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

For a read-only list tool with no output schema, the description covers format, ordering, and scope succinctly. It does not describe the shape of each announcement item, but the schema annotations and low complexity make this acceptable. It is nearly complete for safe 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?

Schema coverage is 75%, and the schema already documents days, full, and course with useful descriptions. The description adds only the 'current courses' interpretation of omitting course, which reinforces the schema but does not meaningfully expand parameter knowledge. The undocumented limit parameter is not compensated for.

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

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

The description clearly identifies the resource (course announcements) and specifies key behavior: newest first and Markdown format. It is immediately distinguishable from sibling tools like get_assignments, get_content, and get_discussions by naming a distinct resource and its presentation.

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 one useful usage clue: 'Omit course for all current courses.' However, it does not explicitly say when to prefer this tool over sibling announcement-like tools, nor does it mention any exclusions or alternatives. The usage context is implied rather than fully stated.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds useful return-content scope, but does not disclose authorization needs, error behavior, or other operational traits. With annotations present, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence that packs the full return scope into a clear, colon-led list. There is zero filler and 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 read-only getter with no output schema, the description gives a solid sense of the return payload, but the gap around assignmentId semantics leaves an agent uncertain how to call it correctly. It is adequate overall, with one clear missing piece.

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 only 50%: course is well described, but assignmentId has no schema description. The tool description does not explain assignmentId format, how to obtain it, or its semantics, so it fails to compensate for the undocumented parameter.

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

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

The description states a specific operation: retrieving one full assignment with a detailed set of contents (instructions, files/links, submissions, feedback, score). The phrase 'One assignment in full' clearly differentiates it from the sibling get_assignments, which presumably returns a list.

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

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

Usage is implied by 'One assignment in full' – it is for detailed single-assignment retrieval – but the description never explicitly mentions when to prefer this over get_assignments or other alternatives, and offers no when-not guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and open-world profile is covered. The description adds value by stating what the returned data contains (due dates, submission status, scores) and the scope of an omitted course parameter, but it does not disclose ordering, pagination, or what 'current courses' means.

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 with zero filler; the main purpose is front-loaded and the usage note about omitting course follows naturally. 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 read-only tool with one optional, fully documented parameter and no output schema, the description covers return content and scoping behavior adequately. The main gap is the lack of differentiation from semantically overlapping siblings like get_upcoming and get_assignment, which an agent must infer on its own.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's 'Omit course for all current courses' essentially duplicates the schema's 'Course filter. Omit for all current-semester courses' and adds no new semantic detail—it is arguably slightly vaguer.

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 resource (Brightspace assignments/dropbox folders) and the return contents (due dates, submission status, scores). The plural form distinguishes it from the singular sibling get_assignment, but it never names or contrasts any sibling, so it stops short of the top score.

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

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

The only guidance is 'Omit course for all current courses,' which is a parameter-behavior note rather than tool-selection guidance. There is no indication of when to choose get_assignments over get_upcoming, get_assignment, or get_grades, and no exclusions or prerequisites are mentioned.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=true, and the description adds meaningful behavioral context: the default result contains instructors/TAs with NetIDs and emails, while everyone=true additionally includes all students. It does not discuss auth, rate limits, or errors, but for a read-only roster lookup the added scope is valuable beyond the annotations.

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

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

The description is a single, efficient sentence that front-loads the primary return content before the flag behavior. It contains no filler and does not repeat what the schema already provides.

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 read-only tool with no output schema, the description conveys the essential returned fields and the only mode-changing flag. A more explicit statement of the default behavior and output shape would improve completeness, but combined with the schema and annotations it is sufficient for straightforward 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?

The schema already documents the course parameter (ID or text) and everyone has a boolean default, so the main missing semantics was the meaning of everyone; the description supplies that by stating everyone=true lists all students too. The default staff-only result is only slightly implicit, but the semicolon structure makes the intended reading clear.

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 resource: course staff (instructors, TAs) with NetIDs and emails, plus the optional expansion to students via everyone=true. It lacks an explicit verb like 'retrieves' or 'lists' for the default mode, but the tool name and return description make the purpose unambiguous and distinct from siblings like list_courses or get_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?

No guidance is provided about when to use get_classlist instead of a sibling tool, and no alternatives or exclusions are named. The everyone flag is parameter-level guidance, not tool-selection guidance, so the description leaves usage context entirely implicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds value by disclosing that the output includes external tool links (Gradescope/Ed) and course website links, and that it provides a structured outline. It doesn't describe pagination or filtering behavior, but given the annotations, this is acceptable and adds useful context beyond the structured fields.

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

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

The description is two sentences with zero fluff. The core purpose is front-loaded, and the additional detail about external tools is appended succinctly. Every sentence earns its place, and it reads naturally.

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 it's a read-only tool with no output schema, the description provides a good overview of the return content (modules, topics, fields, links). It doesn't mention how to filter by module or whether results are paginated, but these are minor gaps. The tool's simplicity and annotations cover most needs, so a 4 is fair.

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

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

Schema description coverage is 100%, so both 'course' and 'module' parameters are already fully documented in the schema. The description does not add any additional meaning about how the 'module' filter works or the format of the 'course' parameter. It only repeats the concept of modules, which is already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool returns a course content outline with modules and topics, including specific fields like topicIds, file types, links, and due dates. It also mentions external tools and course website links, which distinguishes it from assignment/quiz-specific tools. However, it doesn't explicitly name a sibling to contrast with, so it's a 4 rather than 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 implies usage by stating what it returns, but it does not explicitly say when to use this over alternatives like get_assignments or get_quizzes. There is no 'use this for X, use that for Y' guidance. The context is clear enough for an agent to infer the purpose, but explicit routing to siblings 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?

The description's 'read posts' is consistent with readOnlyHint and openWorldHint annotations. It adds Brightspace context and the role of IDs, but it does not disclose return shape or behavior when only course is provided. No annotation contradiction is present.

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

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

The description is a single short, front-loaded sentence with no redundant filler. However, the brevity contributes to ambiguity about the tool's exact function, so it is concise but not fully effective.

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

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

There is no output schema, so the description is the only place to communicate return values, but it does not say what the tool returns. It also fails to explain the required course parameter or what happens when forumId and topicId are omitted, leaving a 3-parameter tool under-specified.

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

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

Schema description coverage is only 33%, so the description should compensate, but it mostly restates forumId and topicId without explaining their semantics or requiredness. It completely omits the required course parameter, leaving the agent without enough parameter-level guidance.

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

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

The description names a Brightspace discussions resource and mentions 'read posts', which goes beyond a tautology. However, it is ambiguous whether the tool lists forums/topics when IDs are omitted or only fetches posts, and it does not explicitly distinguish itself from sibling tools.

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

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

It gives an explicit hint to pass forumId and topicId to read posts. It does not say when to prefer this tool over siblings like get_content or api_get, nor does it address the fact that the schema marks those IDs optional while course is required.

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

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

Annotations already flag this as read-only, and the description adds useful behavior: only released items are returned, and the final grade appears only if it is released. It also names the included fields (points, weight, comments), giving the agent a clear expectation of response content without contradicting annotations.

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

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

One compact sentence communicates scope, return content and a conditional ('if released'), with no filler. It front-loads the subject and avoids repeating annotations or schema details.

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

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

For a simple read-only tool with one optional parameter, the description names what is returned (points, weight, comments) and the conditional final grade. The schema supplies the remaining default behavior (omit course → current semester), so nothing needed for correct invocation is 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 for the single `course` parameter is 100%, with a clear description ('Course filter. Omit for all current-semester courses.'). The tool description adds no additional semantics about the parameter, so the baseline 3 applies.

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

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

The description clearly identifies the resource ('grades') and the return payload ('points, weight, comments', plus final grade if released), and the qualifier 'released' distinguishes it from assignment listings like get_assignments. It is not a 5 because 'per item' does not spell out which grade-item types are covered.

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 phrasing 'My released grades' implies the primary use case—viewing the caller's own visible grades—and the optional course filter is documented in the schema. However, the description never states when to use this over siblings such as get_assignments or get_quizzes, nor any exclusion criteria.

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

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

The annotations provide readOnlyHint and openWorldHint, so the description need not restate safety. It adds some output context by enumerating fields, but it does not disclose default scoping (current-semester), pagination, or response structure, leaving meaningful behavioral gaps.

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

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

The description is a single efficient sentence with no filler and the resource is front-loaded. It could be improved by starting with an active verb, but it's appropriately compact for the information provided.

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 getter with annotations and no output schema, the description is adequate but sparse. It does not clarify whether the result is a list, mention default course filtering, or elaborate on the returned items beyond a few fields, leaving modest gaps for an agent to infer.

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

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

With 100% schema description coverage for the single 'course' parameter, the baseline is 3. The description adds nothing about parameters beyond what the schema already states, so it neither improves nor harms parameter understanding.

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

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

The description names the resource (Brightspace quizzes/exams) and the key attributes returned (open/due/close times, time limits, attempts). This distinguishes it from sibling tools like get_assignments, though it relies on the tool name for the verb and does not explicitly state 'list' or 'retrieve'.

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 get_upcoming, get_assignments, or other siblings. The only usage context is the course filter description in the schema, which is not part of the description and does not help choose between similar tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, but the description adds valuable behavioral context: results are in NYU local time and the tool scans announcements for deadlines outside Brightspace. This goes beyond the structured annotations and clarifies the open-world 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?

Three sentences, each earning its place: the first defines the scope and contents, the second adds timezone and external-scan behavior, and the third gives the usage directive. It is front-loaded and free of filler.

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

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

For a tool with no output schema and five optional parameters, the description does well by covering the main return categories and the external-announcement scan behavior. It could mention output ordering or how the optional parameters shape results, but the schema covers parameter details and the description gives enough for an agent to call it appropriately.

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 80%, which is high, so the baseline is 3. The description lightly echoes the course parameter with 'or one course' and the scanAnnouncements behavior with 'scans recent announcements', but it does not add meaningful detail beyond the schema for parameters like days, pastDays, or includeDone.

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: it aggregates upcoming deadlines across current courses or a single course, and explicitly enumerates the item types returned (assignments with submission status, quizzes, readings with completion status, instructor calendar events). It also differentiates itself from sibling tools like get_assignments and get_quizzes by positioning itself as the starting point for 'what's due'.

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 says to 'Start here for what's due', giving the agent a strong signal about when this aggregate tool is appropriate. It also notes that it scans announcements for external deadlines, which helps distinguish it from direct course-content tools. However, it does not explicitly state when to prefer siblings like get_assignments or get_announcements for narrower queries.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds behavioral detail beyond the annotations: the default term selection and the ability to parse NYU codes like FA26_CSCI-UA_310_1_040. It does not contradict the annotations.

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

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

The description is two sentences with no filler. The core purpose is front-loaded ('List Brightspace courses with ids'), and the second sentence provides essential default and parsing behavior without unnecessary detail.

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

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

For a single-optional-parameter tool with no output schema, the description gives enough context to call it correctly: what it lists, what the default term is, and what code formats it parses. A fuller return-format description would be helpful but is not essential given the simple scope.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by clarifying that the tool parses full NYU codes like FA26_CSCI-UA_310_1_040, which is more specific than the schema's term-code examples (FA26, SP26, etc.). This helps an agent understand what forms of input are accepted.

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: 'List Brightspace courses with ids.' This clearly distinguishes it from sibling tools that target specific items like assignments, quizzes, or grades. The mention of NYU code parsing adds a concrete scope beyond the generic 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?

The description provides clear usage context by stating the default behavior ('Defaults to the current NYU semester') and showing what kinds of NYU codes are accepted. It does not explicitly name alternatives or exclusions, but the context is sufficient to know when this tool is appropriate.

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

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

Discloses key behavioral traits beyond the annotations: it opens a Chrome window, requires the user to complete Duo on their phone, waits up to ~100s, and has a defined fallback when pending. This goes well beyond readOnlyHint=false and openWorldHint=true.

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

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

Three sentences with no filler. The main action is front-loaded, followed by the trigger condition, user dependency, timeout, and next-step guidance.

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 interactive login tool, the description covers the full workflow: when to call it, what happens, what the user must do, how long it waits, and what to do on timeout. The reference to auth_status closes the loop with an existing sibling 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 and the input schema is fully covered, so the baseline of 4 applies. There are no parameter semantics for the description to add.

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?

States a specific verb and resource: open a Chrome window for NYU NetID + Duo login. It is clearly distinguishable from the sibling auth_status, which is a status-checking 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?

Explicitly says to use it when other tools report the session is not logged in. It also gives follow-up instructions to tell the user and call auth_status if login is still pending, so the agent knows exactly when and how to proceed.

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

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

The description discloses useful behaviors such as per-page extraction, format handling, and saving binary files locally. However, it directly contradicts the readOnlyHint=true annotation, since saving binary files to ~/Downloads/brightspace/<course>/ is a local side effect on the environment.

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 front-loads the verb and resource, then enumerates supported formats and the binary-file destination. There is no filler, repetition of schema content, or unnecessary elaboration.

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

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

The description covers core extraction behavior, formats, and the binary fallback path, but with six parameters and no output schema it omits the returned text shape/paging behavior and does not distinguish itself from content-related siblings. It is adequate for simple calls but not fully complete for a complex extraction 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 descriptions cover course, dir, save, and offset, while topicId and maxChars are undocumented, and the description does not fill those gaps. It adds format-level context and 'Read a content topic' gives topicId a minimal semantic anchor, but it never explains how offset, maxChars, dir, or save affect the read.

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?

States a specific action ('Read'), a clear resource ('a content topic'), and the concrete behavior (extracts text from PDF/DOCX/PPTX/HTML/ZIP and plain text/code). This is specific enough to distinguish it from content-related siblings like get_content or download_file, even without naming them.

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

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

The description implies when to use the tool (when text content from a topic's files is needed) and what file types it handles, but it never names alternatives like get_content or download_file or states when not to use them. With several content-related siblings, the routing guidance is left mostly to inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description does not need to restate safety. It adds useful context about the search scope ('across current courses') and that it matches by title, but it does not disclose details like result ordering, limit, or whether partial matches are 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, front-loaded sentence that states the core purpose and scope before giving illustrative examples. Every part earns its place, with no filler or redundant restating of the tool name.

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

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

For a simple two-parameter search tool with readOnly and openWorld annotations, the description is mostly complete. It explains what to search for, the scope, and gives concrete query examples. It could go slightly further by noting whether results are limited or how matches are ranked, but nothing essential for a basic invocation is missing.

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

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

The query parameter has no schema description, but the tool description compensates by explaining that the query is a title search and providing realistic examples. The course parameter already has a schema description, so the description does not need to repeat it. Overall, it adds meaningful semantic value beyond the schema.

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

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

Description states a specific action (Find) and resource (modules/topics by title) with clear scope (across current courses). Concrete examples ('syllabus', 'hw3', 'lecture 5 slides') make the purpose immediately understandable and distinct from sibling tools like get_content or read_content, which imply direct retrieval rather than search.

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

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

The description gives clear context for when to use this tool: when you need to locate modules/topics by title, especially with user-like queries such as 'syllabus' or 'hw3'. It does not explicitly name alternatives or exclusions, but the examples and scope make the intended use case clear.

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