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

With no annotations, the description carries the full behavioral burden, and it does disclose the scope of the checks performed. However, it says nothing about whether the call is purely read-only, how failures are surfaced, or what the results look like, leaving meaningful gaps for a diagnostic tool.

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

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

A single, front-loaded sentence with no filler. Every item listed earns its place by naming a distinct check, and nothing is redundant.

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 output schema and no annotations, the description should ideally indicate what a result contains or how a failure is signalled. It enumerates the checks but leaves the agent guessing at the response shape and how to act on the outcome.

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 takes zero parameters, so the baseline score of 4 applies; there is no parameter surface the description needs to compensate for.

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

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

The verb 'Check' plus a specific list of resources (Ufora host, authentication, API readiness, current-course discovery) makes the tool's job unambiguous, and it is clearly distinct from read-oriented siblings like whoami or list_courses. It lacks any explicit contrast with those siblings, but the diagnostic framing separates it well.

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 stated condition for when to run this versus other tools, nor any mention of prerequisites or ordering (e.g. 'run before other tools to verify setup'). The diagnostic nature hints at troubleshooting use, but the agent is left to infer it entirely.

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

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

With no annotations, the description must carry the behavioral burden; it does disclose the full-body return format and the academic-year aggregation scope, which are genuine traits. It omits authorization needs, result limits/pagination, and ordering, so disclosure is partial rather than rich.

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

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

Two tight sentences with the primary behavior front-loaded and the fallback scope immediately after; no filler. The trailing Activity Feed caveat is slightly tangential but still earns its place as a disambiguation.

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 2-param, no-annotation, no-output-schema tool, the description covers return payload and default scope but leaves the 'since' filter and any limits unaddressed. It is adequate but leaves an agent guessing on one whole parameter.

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% and only 'course' is addressed (absence triggers cross-course aggregation). The 'since' parameter is never mentioned, so its format (date? ISO? relative?) is left entirely to guesswork, leaving one of two parameters 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?

States a specific verb and resource ('Return actual course announcements') plus the payload ('full body text/HTML'), which separates it from sibling summary-style tools like get_updates or get_snapshot. It does not name a sibling explicitly, 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?

Explains the default behavior when 'course' is omitted (aggregate News across current academic-year courses) and disambiguates from Brightspace's Activity Feed, which is a useful routing hint. However it never states when to prefer this over get_updates/get_discussions or when aggregation is inappropriate.

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

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

No annotations exist, so the description carries the full behavioral burden. It implies a read-only operation and names the returned fields, but says nothing about permissions, pagination, sorting, or whether unpublished folders are excluded.

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 tightly written sentence with the resource and scope front-loaded and no filler. Nothing is wasted.

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 no output schema, the description is minimally adequate. However, with zero schema coverage and no annotations, it omits parameter format and return-shape details an agent would need to call it confidently.

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

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

Only one parameter with 0% schema description coverage. 'For one course' loosely ties to the 'course' parameter and scopes it to a single course, but the description gives no clue about expected format (course ID vs. name) or how the value is resolved.

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 ('Return'), resources ('assignment folders and due dates'), and scope ('for one course'). It is clear, but it does not distinguish itself from nearby siblings such as get_upcoming_due or get_overdue, so an agent cannot route on the description alone.

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, no prerequisites, and no mention of alternatives. The reader must infer that this retrieves all assignments for a course rather than filtered due-date views offered by siblings like get_overdue.

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 disclosure burden, yet it says nothing about permissions, whether the result is read-only (inferable only from the name), pagination, ordering, or what happens when no events exist. 'Upcoming' is never defined in the description itself, leaving the time-window behavior opaque.

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 tight sentence with no filler, and the core purpose is front-loaded. It is perhaps too terse given the unstated 'days' parameter, but there is no wasted text.

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

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

For a two-parameter tool with no annotations and no output schema, the description should at least define the look-ahead window and note the optional course scoping format. It mentions only one of two parameters and leaves behavioral expectations entirely to inference.

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 both parameters are undocumented in structured data. The description covers the 'course' filter conceptually but never mentions the 'days' parameter or its default of 14, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('Return upcoming calendar events') and adds a scoping qualifier ('optionally restricted to one course'). It is distinguishable from list-style siblings like get_assignments or get_announcements, though it does not explicitly contrast itself with the closest sibling, get_upcoming_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?

There is no statement of when to prefer this tool over alternatives such as get_upcoming_due, get_updates, or get_snapshot. The only usage hint is the passive 'optionally restricted to one course', which implies but never states the filtering scenario.

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 discloses the shape of the return payload in detailed mode, but says nothing about permissions, course-identifier requirements, pagination, or failure behavior for a tool that takes a required 'course' argument.

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 compact sentence that front-loads the core purpose and appends the mode distinction. Every clause carries information; nothing is redundant.

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 read tool with no annotations or output schema, the description covers what the tool returns but omits the identity/format of the required 'course' argument. Adequate but with a real gap for correct 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 description coverage is 0%, so the description must compensate. It usefully explains the 'detailed' flag (descriptions, URLs, types, nesting), but leaves 'course' entirely unexplained — no indication whether it expects an ID, code, or 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?

States a specific verb and resource ('Return course modules/topics') and even outlines what the detailed payload contains. It is clear on its own, though it does not explicitly distinguish itself from siblings like get_course_overview or search_course_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?

There is no guidance on when to choose this tool over get_course_overview, search_course_content, or read_course_material. The only hint is the detailed-mode tradeoff, which is parameter behavior rather than selection advice.

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 supplied, so the description carries the full burden. It implies a read-only aggregate and discloses the composite sections returned, which is the most important behavioral trait, but says nothing about permissions, cost, rate limits, or whether it silently truncates results.

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

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

A single front-loaded sentence with no filler, and the resource is named before the payload list. It is efficient, though the colon-list format leans on enumeration rather than explanation.

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

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

With no annotations, no output schema, and four wholly undocumented parameters, the description should explain the aggregation behavior and parameter effects but does not. An agent still cannot tell what 'days' scopes, whether 'include_content' can disable a listed section, or how results are shaped.

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% across four parameters. The description's mention of announcements/content loosely gestures at announcement_limit and include_content, but 'days' (the default 14 window) and the 'course' identifier format are completely undefined, and no defaults or units are explained, so the description fails to compensate for the coverage gap.

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

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

The description gives a specific verb ('Return') and resource ('high-value context for one course') and enumerates the payload sections: overview, announcements, assessments, deadlines, content. It reads as an aggregator, but it never explicitly distinguishes itself from siblings like get_course_overview, get_announcements, or get_course_content that cover the same ground individually.

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 bundled call versus the many narrower siblings. An agent seeing get_course_overview, get_announcements, and get_assignments alongside this tool has no stated rule for choosing one over the other.

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. 'Return' implies a read, but it says nothing about required permissions/enrollment, error behavior, or what 'dedicated' overview means versus any other overview source. Minimal disclosure for a tool with zero annotation coverage.

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

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

A single tight sentence with no padding; the resource and return content are front-loaded. It is efficient, though arguably too sparse for the gaps it leaves.

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 output schema, no annotations, and an undocumented required parameter, the definition is incomplete. It gestures at return content but omits parameter format and any behavioral/selection context an agent needs to call it correctly.

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

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

Schema description coverage is 0% for the single 'course' parameter, so the schema gives no format or source for it. The description never clarifies whether course is a code, name, or ID, nor how to obtain a valid value, so it fails to compensate for the 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?

States a specific verb+resource ('Return the dedicated Ufora Course Overview') and names what content it carries (course expectations and description text). However, it offers no differentiation from close siblings like get_course_context or get_course_content, leaving the agent to guess which one to pick.

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 when-to-use guidance, no prerequisites, and no mention of alternatives despite several overlapping siblings (get_course_context, get_course_content, list_courses). The agent must infer selection entirely on its own.

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 implies a read operation but says nothing about pagination, whether posts are nested under topics/forums in the response, authentication needs, or how much content 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?

A single, front-loaded sentence with no filler, and the resource scope is stated immediately. It is efficient, though it stops short of adding any routing or format 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?

The description sensibly communicates the forum/topic/post hierarchy that will be returned, which is useful given there is no output schema. However, with no annotations and an undocumented required parameter, it leaves notable gaps for correct 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 description coverage is 0% for the single 'course' parameter, and the description only echoes that it operates on 'one course'. It does not clarify whether the value is a course ID, code, or name, leaving the key input ambiguous.

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 ('Return') and resource ('discussion forums/topics/posts') and scopes it to one course, which is clearly distinct from siblings like get_assignments or get_announcements. It does not explicitly name an alternative sibling, so it falls 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?

There is no guidance on when to use this tool versus related read tools such as get_course_content or get_updates, nor any prerequisites or exclusions. Usage must be inferred from the tool name and resource alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses a scope constraint (only currently resolved courses), but says nothing about read-only nature, authentication requirements, pagination, or return format.

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

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

A single, front-loaded sentence with no wasted words. It is appropriately sized for a zero-parameter, read-only retrieval 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?

For a simple zero-parameter tool, the description is minimally adequate. However, with no output schema, it should provide more detail about what "final grades" contains or how results are structured, which it does not.

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

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

The tool has zero parameters, so there is no parameter schema for the description to supplement. Baseline score of 4 applies for a parameterless tool.

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 ("Return") and resource ("final grades") with a clear scope ("currently resolved courses"). It is distinguishable from broader siblings like get_grades by the "final" qualifier, though it does not explicitly name or contrast with that 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?

Provides no explicit when-to-use guidance, prerequisites, or alternatives. The phrase "currently resolved courses" implies some context, but an agent is left to infer when this tool should be chosen over get_grades or other grade-related siblings.

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

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

With no annotations, the description carries the full burden. It does not disclose permissions, whether it is read-only (implied but not stated), pagination, or how much feedback is returned. Only the bare scope is given.

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 short sentence that is front-loaded with the verb and resource. It is efficient and wastes no words, though it could be slightly more explicit about scope.

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 annotations, no output schema, and 0% parameter documentation, the description is too thin. It omits prerequisites, response shape, and distinctions from sibling get_final_grades.

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 single 'course' parameter, likely a course identifier. It does not specify the expected format (ID vs name) or valid values, leaving a 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?

States a specific verb (Return) and resources (grade items and feedback) scoped to one course. It is distinguishable from get_final_grades, which implies only final course grades, but the description does not explicitly name that sibling to clarify the distinction.

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

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

No when-to-use guidance is given. With a close sibling like get_final_grades, the description should clarify when to request per-item grades vs final grades, but it provides none.

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; the verb 'Return' does signal a non-destructive read, which is the main behavioral fact an agent needs here. It says nothing about what counts as an item, ordering, empty results, or whether the scope respects enrollment, all of which would have to be discovered empirically.

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

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

A single front-loaded sentence with zero filler and the scope constraint placed after the core action. It is efficient, though the brevity is a symptom of under-specification rather than deliberate precision.

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, no annotations, and no output schema, the description is the only documentation, and 'Ufora items' is vague about whether assignments, quizzes, and discussions all appear. For a low-complexity zero-argument listing tool this is minimally adequate, but the item taxonomy and default scope are left undefined.

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 takes zero parameters, so there is no parameter surface for the description to explain and the baseline of 4 applies. The description appropriately restricts itself to defining the implicit scope (current courses) rather than inventing parameter detail.

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

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

States a specific verb ('Return') plus a clearly scoped resource ('overdue Ufora items across current courses'), which is enough to separate it from the name-adjacent sibling get_upcoming_due by implication. It stops short of explicitly naming that sibling, so an agent must infer the overdue-vs-upcoming split rather than being told.

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 the embedded scope qualifier 'current courses,' which implicitly excludes past/archived courses. There is no when-to-use statement, no prerequisite, and no named alternative (e.g., get_upcoming_due for future deadlines), even though the sibling list contains an obvious counterpart.

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 and mentions 'timing metadata' in the return, but says nothing about pagination, permissions, error behavior, or whether quiz questions/answers are included.

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 tight sentence with the resource and scope front-loaded and no filler. It is efficient, though arguably too terse to earn a 5 given the missing detail elsewhere.

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

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

With no annotations and no output schema, the description is the only source of behavioral detail, and it is far too thin: undefined course identifier, undefined 'timing metadata', and no return shape for a tool an agent must call correctly on the first try.

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 single 'course' parameter is undocumented everywhere. The description says 'for one course' but never specifies whether that is an ID, short name, or code — the agent has to guess the identifier format.

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 (return) and resource (quizzes) scoped to one course, plus hints at extra payload (timing metadata). Siblings are all distinct resources (grades, assignments, discussions), so no explicit sibling differentiation is needed, but it doesn't mention how this differs from a broader course fetch.

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, no prerequisites, no alternatives named. The only signal is the implied 'fetch quizzes for a course' from the verb, which is the bare minimum 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, the description carries the full behavioral burden and supplies almost none of it. It says nothing about authentication/scope requirements, the return shape, rate limits, or whether 'shallow' changes cost/behavior. Only the word 'broad' hints at scope.

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

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

It is a single front-loaded sentence with no padding, which is structurally clean, but it is under-specified rather than genuinely concise. Brevity here costs 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?

For a tool with three undocumented parameters, no annotations, and no output schema, the description is grossly incomplete. It omits what is returned, what the parameters mean, and when the tool should be used, giving the agent almost nothing to act on.

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 there are three parameters (course, shallow, since_hours), yet the description mentions none of them. It does not explain what 'shallow' toggles or what 'since_hours' scopes, so it fails to compensate for the total coverage gap.

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

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

The description pairs a verb ('Return') with a resource ('snapshot'), so the basic action is clear, but 'broad AI-oriented academic snapshot' is vague jargon that never states what data the snapshot actually contains or how it relates to the many sibling readers (get_grades, get_upcoming_due, get_announcements, etc.). An agent cannot tell what it will get or why this differs from the specific 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?

There is no explicit when-to-use guidance. 'broad' weakly implies it aggregates many categories, but nothing tells the agent when to prefer this over the specific sibling tools or when to avoid it. The routing decision is left entirely 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a safe read, but discloses nothing about return format, ordering, whether it aggregates assignments/quizzes/discussions, or any auth/rate-limit constraints.

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

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

A single front-loaded sentence with zero filler. The scope constraint arrives immediately and nothing is wasted.

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 read tool with no output schema and no annotations, the description is minimally adequate. It leaves open what 'items' encompasses and how results are shaped, which an agent would want to know before calling.

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% for the single 'days' parameter, so the schema alone is bare. The description partially compensates by mapping 'N days' to that parameter, but omits the default (14) and the accepted value format.

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 ('Return items due across current Ufora courses') with a scope qualifier ('next N days'). An agent can distinguish it from get_overdue by the future-window framing, though the description stops short of naming that sibling explicitly.

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 'next N days' framing implicitly bounds usage to upcoming items versus past-due ones, which is decent context. But there is no explicit when-to-use, when-not-to-use, or named alternative such as get_overdue or get_calendar.

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 never states that the tool is read-only, whether it requires authentication, what a 'counter' actually is, or how the two counter types (unread vs update) are shaped. For an unannotated tool this leaves the agent guessing.

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 compact sentence with the scope qualifier front-loaded after the action. Nothing is wasted, though it is arguably too terse for the behavioral gaps it leaves open.

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?

No output schema and no annotations exist, so the description must explain what a returned counter looks like and any safety profile. It says only that counters are returned, leaving return shape, count semantics, and read-only nature undocumented.

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% and the single 'course' parameter has no description, so the description must compensate. The phrase 'globally or for one course' does usefully explain the omitted/null default behavior, but adds no format, type, or resolution detail beyond that.

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 clear verb (Return) and resource (unread/update counters) with explicit scope (globally or for one course). It does not name or differentiate itself from any sibling such as get_announcements or get_course_overview, which is the only thing keeping it from 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?

There is no statement of when to use this tool versus the many sibling read tools, nor any prerequisites or exclusions. The only usage hint is the implicit global-vs-course scope, which is inference rather than 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 full burden. It discloses the default scope (current academic year) and the effect of include_all, which is useful behavioral context. However, it omits whether this is a read-only operation, whether results are paginated, or what the return structure looks like.

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, and the conditional behavior is front-loaded. The structure efficiently conveys the two modes. Minor room for improvement in connecting the two sentences more explicitly.

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 list/search tool with no annotations and no output schema, the description covers the essential behavioral modes and parameter effects. However, it leaves gaps around read-only safety, result format, and explicit sibling differentiation that an agent might need to choose correctly among the many sibling tools.

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

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

Schema coverage is 0%, so the description must compensate. It explains the semantics of 'query' (searches by name/code/ID across history) and 'include_all' (expands from current year to all). This adds meaningful meaning beyond the bare schema, but the description of include_all is somewhat terse and doesn't clarify its interaction with query.

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

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

The description clearly states a specific verb and resource ('List courses', 'search real course offerings by name/code/ID'). It distinguishes two modes of operation (list vs. search), though it does not explicitly name sibling tools like get_course_overview or search_course_content to differentiate further.

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 through the conditional behavior: without QUERY it lists the current academic year, with QUERY it searches all offerings. However, it does not state when to prefer this tool over alternatives like get_course_overview or search_course_content, leaving the agent to infer.

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

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

No annotations exist, so the description carries the full disclosure burden, and it provides almost nothing: no mention of required enrollment/permissions, whether reads are side-effect-free, or truncation behavior (the max_chars default implies truncation but that lives in the schema, not the description). What gets returned and whether access is scoped to the caller's own courses is entirely 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?

A single front-loaded sentence with no filler. It is efficiently written, though its brevity is partly a symptom of under-specification rather than disciplined concision.

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 3-parameter tool with no annotations, no output schema, and 0% parameter coverage, the description is far too thin. It should at minimum explain identifier formats, truncation via max_chars, and how it differs from the many overlapping sibling getters.

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 all three parameters are undocumented. The description's list of material types loosely hints at what 'material' might accept, but it never explains the identifier format for 'course' or 'material', nor the meaning/units of max_chars. Compensation for the coverage gap is minimal.

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

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

The verb 'Read' plus an enumeration of resource types (Course Overview, module body, topic, PDF/text) gives a rough sense of the operation. However, this overlaps heavily with siblings like get_course_overview and get_course_content, and the description never clarifies how read_course_material differs from them. An agent cannot confidently pick this over the 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?

No when-to-use guidance, no prerequisites, and no alternatives named. With siblings such as get_course_content and get_course_overview in the set, the absence of any routing hint is a real gap for a read 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 behavioral burden. Search implies a read-only operation, but nothing is said about result volume, the role of the limit parameter, ordering, or what happens when a query matches nothing — all relevant for a tool with no output schema.

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

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

A single efficient sentence with the scope front-loaded and no filler. It is concise, though arguably under-specified rather than optimally dense.

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

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

With no annotations, no output schema, and 0% parameter documentation, the description should do more. It omits course identifier format, pagination via limit, and return-shape expectations, leaving the agent to guess at core invocation 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% across all three parameters, so the description must compensate. It only hints that 'course' is a single course identifier; the query matching semantics and the limit/pagination behavior are entirely undocumented in both schema and 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 states a specific verb (Search) and enumerates the resource scope: Course Overview, module bodies, topics, and descriptions, constrained to one course. This distinguishes it reasonably well from retrieval siblings like get_course_content and read_course_material, though it never explicitly names the distinction.

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

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

There is no guidance on when to use this search tool versus get_course_content, get_course_overview, or read_course_material. The one-course constraint is implied but no conditions, prerequisites, or alternatives 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 provided, so the description carries the full burden. It implies a read-only identity lookup, but does not disclose required authentication scope, what happens if unauthenticated, or the response shape (since no output schema exists). Moderate 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?

A single, well-formed sentence with no waste. The purpose is front-loaded and clear.

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, no-annotation, no-output-schema tool, the description is minimal. It does not describe return values (since no output schema) or error conditions, which could be useful for an agent to know. However, the core purpose is fully stated.

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?

Zero parameters, so baseline is 4. The description does not need to explain parameters, and schema coverage is 100% (though empty). No additional parameter meaning is required.

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 ('Return') and resource ('currently authenticated UGent Ufora user'). It is clearly distinguishable from siblings like doctor or list_courses, which deal with diagnostics or course 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?

Implied use is to check identity when authenticated, but the description offers no explicit when-to-use guidance or alternatives. A sibling like 'doctor' might serve as a diagnostic alternative, but this is not addressed.

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