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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint, and openWorldHint, so the safety profile is covered. The description adds genuinely useful behavior context beyond that: it is a composite read that aggregates four distinct resources in one call, which the annotations do not convey.

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, front-loaded with what is returned and followed by when to use it. Every clause earns its place with no filler.

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

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

The description enumerates the aggregated return contents (assignment, rubric, submission status, syllabus), which substitutes well for the missing output schema. The remaining gap is parameter meaning, which is a schema-side deficiency rather than something the description ignores.

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 both required parameters (courseId, assignmentId), and the description does not explain their format or the numeric-ID pattern. "Read one assignment" hints that a single assignment identifier is needed, but neither parameter is clarified, leaving the schema to do work it does not do.

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 (Read) and resource bundle (assignment, rubric, submission status, syllabus), which distinguishes it from single-resource siblings like get_syllabus and get_course_work_status. It is clear what the tool returns, though it does not explicitly name which sibling to use instead.

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?

"Use this before helping prepare an assignment or checking whether it is submitted" gives concrete triggering contexts. It lacks explicit when-not-to-use guidance or named alternatives, but the intended scenarios are unambiguous.

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 readOnly, idempotent and non-destructive behavior, so the safety profile is covered. The description adds real value beyond that: it discloses the return content (missing flags, zero scores, excused state), the pagination requirement ('Follow every page'), and an explicit non-capability (no course average).

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?

Five short sentences, front-loaded with the core purpose and free of padding. The pagination instruction earns its place; wording is efficient throughout.

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 exists, so the description must describe returns, and it does (missing flags, zero scores, excused state, pagination). With read-only annotations covering safety and only 2 params, this is nearly complete; the gap is parameter-level meaning for courseId.

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

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

Schema description coverage is 0%, so the schema only gives types/patterns, not meaning. The description partially compensates by implying pagination behavior via 'Follow every page', but adds nothing about courseId's semantics or the page/courseId relationship. Baseline 3 given the low coverage is earned only marginally.

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 ('Check missing work and assignment scores') and immediately differentiates from the sibling get_study_overview by noting it includes graded zeros an overview may omit. An agent can select this over get_study_overview without opening either schema.

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?

Gives a clear usage context ('Use for missing-assignment or grade concerns') and a negative boundary ('Does not calculate a course average'), which steers agents away from expecting an aggregate. It stops short of naming an explicit alternative tool for average/overview needs (e.g. get_study_overview).

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 read-only, idempotent, and open-world behavior, so the safety profile is covered. The description adds real context beyond them: no course IDs are required, results are paginated via nextPage, and the payload is deliberately non-exhaustive. It stops short of describing ordering or freshness of the previews.

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?

Four short sentences, all front-loaded: purpose, then setup (no IDs needed), then continuation mechanics, then a boundary disclaimer. Every sentence carries decision-relevant information with no 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?

With no output schema, the description usefully enumerates what comes back (classes, syllabus excerpts, upcoming/overdue previews) and how to continue paginating. The remaining gap is the undocumented page parameter, which leaves the only input 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?

The single 'page' parameter has 0% schema description coverage, so the description must compensate. 'Follow nextPage for remaining classes' signals that pagination exists and how to continue, but it never explains what the page input means, its bounds, or how nextPage maps onto it.

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

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

States a specific verb+resource with scope: it returns active classes, syllabus excerpts, and assignment previews in one call. It clearly positions itself as the entry-point overview relative to the focused siblings get_syllabus and list_assignments.

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

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

Explicitly says when to use it ('start here for a new schoolwork conversation') and when not to ('this is an overview, not an exhaustive deadline check'), and routes follow-up work to the focused tools for syllabi, rubrics, and all assignments.

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, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered by structured data. The description contributes only the fact that the timezone accompanies the syllabus, which is modest added value 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?

A single short sentence with zero filler, front-loading the core action and resource. Nothing 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 single-parameter read tool with no output schema, the description adequately conveys what is read and that timezone is included. However, the sole parameter is undocumented anywhere, leaving the agent to infer the courseId identifier's format and source.

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 one required parameter (courseId) with 0% schema description coverage — the schema only supplies a numeric-string pattern, no meaning. The description never mentions courseId, its format, or where to obtain it, 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 (Read) and resource (the teacher's syllabus), plus the additional payload (course timezone). It is distinguishable from siblings like list_courses and get_study_overview, though it does not explicitly name which sibling to prefer.

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

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

The description gives no indication of when to use this tool versus get_study_overview or get_course_work_status, nor any prerequisites. Usage context is entirely implied by the name.

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 readOnly, idempotent, and openWorld, so safety is covered. The description adds no behavioral context such as pagination behavior (the schema exposes a 'page' param) or what the announcement entries contain; the second sentence about teacher-authored source material is a disclaimer rather than behavioral disclosure.

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

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

The first sentence is tight and front-loaded, but the second sentence about 'teacher-authored source material' is ambiguous in purpose and adds little actionable value for an agent deciding how to call the 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?

With no output schema, two undocumented parameters (including pagination), and no usage context, the definition leaves too much unstated for an agent to call this tool confidently alongside nine siblings.

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

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

Schema description coverage is 0% and the description mentions no parameters. 'course announcements' weakly implies courseId, but the 'page' pagination parameter is completely undocumented in both schema and description, so the agent gets no guidance on it.

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

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

States a clear verb+resource: 'Read course announcements' tells the agent exactly what it retrieves. It does not, however, distinguish itself from siblings like list_assignments or read_page, so an agent must infer the boundary from the resource name 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 indication of when to use this tool versus the many sibling list/read tools, and no mention of required prerequisites. The scope is implied only by the word 'announcements'.

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, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful non-schema behavior: that responses carry a nextPage cursor to page through all work. It does not, however, describe response shape, error behavior or rate limits.

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

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

Two short sentences, purpose front-loaded before the pagination note, with no redundant or filler text. Every clause carries 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 read-only list tool with no output schema and annotations covering safety, the description conveys the returned content and the pagination mechanism, which is enough for an agent to call it. Error conditions and the exact meaning of the page parameter remain unaddressed.

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 two parameters. 'For a course' loosely implies courseId, but the 'page' parameter is never explained in the description, and the 'nextPage' mention refers to the response rather than the request param. The description fails to compensate for the documentation 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 (read) and resource (assignments) plus the content returned: deadlines, availability and submission state, scoped to a course. It is clear what the tool does, but it never differentiates itself from conceptually adjacent siblings like get_course_work_status or get_assignment_context.

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

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

There is no when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. The only implicit signal is 'for a course', which hints at the courseId requirement but says nothing about choosing this over get_course_work_status.

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 readOnly, idempotent, openWorld, and non-destructive semantics, so the bar is low. The description adds a genuinely useful behavioral fact beyond them: results are paginated and iteration should continue until nextPage is null. Minor friction: it references 'nextPage' while the only input parameter is 'page', which is mildly confusing without the (absent) output schema to clarify.

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, zero waste, with the core action front-loaded and the pagination caveat second. Every clause earns its place.

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

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

For a simple read-only list tool with safety annotations and no output schema, the description plus annotations cover what an agent needs to call it. The one real gap is the unexplained relationship between the 'page' parameter and the 'nextPage' continuation it mentions.

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 one optional parameter with 0% schema description coverage, so the description must carry meaning. It mentions pagination, which gestures at the 'page' parameter's purpose, but never explains how 'page' interacts with 'nextPage' or the valid range. Partial compensation only, so the 3 baseline 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 gives a specific verb and resource ('List your active Canvas courses') with a scoping qualifier ('active') that separates it from sibling list_* tools like list_assignments and list_modules. It stops short of naming how it differs from those siblings, so it lands just below the top tier.

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

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

It implies the context (listing courses) but never states when to prefer this over siblings such as get_course_work_status or get_study_overview, nor any exclusions. The pagination instruction is operational guidance rather than usage routing, leaving selection largely 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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description usefully adds that returned items include page slugs and source links, which partially compensates for the absent output schema, but says nothing about pagination behavior for the 'page' parameter.

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

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

A single efficient sentence with the core action front-loaded and no wasted words. It is appropriately sized, though brevity here partly reflects under-specification rather than disciplined conciseness.

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

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

With no output schema, the description partially compensates by naming the item contents. However, with zero schema description coverage and no guidance on pagination or parameter meaning, the definition is only minimally adequate for a three-parameter tool.

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

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

Schema description coverage is 0% across three parameters (courseId, moduleId, page), and the description provides no meaning for any of them. An agent gets no hint about what 'page' controls or the ID formats expected beyond the schema's regex 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?

States a specific verb ('Read') and resource ('items inside a module'), and adds what the items contain (page slugs and source links). It is clear what the tool does, though it does not explicitly differentiate itself from siblings like list_modules or read_page.

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 versus list_modules, read_page, or get_syllabus. The agent must infer usage purely from the name and one-line description, with no conditions or exclusions 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 declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds only that results include prerequisites and availability; it says nothing about pagination or result limits despite the page parameter.

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

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

A single front-loaded sentence with zero wasted words. It is efficient, though the brevity borders on under-specification rather than genuine conciseness.

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

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

For a two-parameter read tool with no output schema and 0% schema coverage, the description should explain the ID requirement and pagination behavior. Neither is addressed, so the agent lacks enough to call it confidently beyond the bare minimum.

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 nothing documents courseId (a required constrained ID) or page (pagination with a 10000 max). The description mentions neither parameter, leaving the agent no meaning beyond the raw schema names.

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

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

States a specific verb (Read) and resource (course modules) plus the informational payload it returns (prerequisites and availability). It does not explicitly distinguish itself from the close sibling list_module_items, 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?

No guidance on when to use this versus list_module_items, list_courses, or get_study_overview, and no prerequisites or exclusions mentioned. The agent must infer the applicable scenario from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, destructiveHint=false, so the safety profile is fully covered. The description adds only that the page slug comes from module items; it does not mention required permissions, whether the page is published, or rate limits. With annotations covering behavior, the bar is lower, but the description still adds minimal beyond the slug-source note.

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

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

Single, front-loaded sentence with zero waste. The key scope constraint ('from module items') is placed at the end but remains clear and compact.

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 tool with annotations covering the safety profile and no output schema, the description is adequate but leaves gaps. It does not explain what a 'page slug from module items' concretely means, how to obtain it, or what the returned page contains, and courseId semantics are absent.

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

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

Schema description coverage is 0%, so the schema provides types and patterns but no semantic explanation. The description partially compensates by indicating pageSlug is a 'page slug from module items', giving context for that parameter. However, courseId is left unexplained, and no format or source details beyond the slug note are provided. Baseline 3 is appropriate given limited compensation for the coverage gap.

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

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

Clear verb (Read) and resource (Canvas course page) with a specific scope note ('using a page slug from module items'). This implies the slug source is a module item, distinguishing it from a generic content fetch, but doesn't explicitly contrast with siblings like list_module_items or get_syllabus.

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

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

No guidance on when to use this tool versus alternatives. The phrase 'from module items' hints at a prerequisite source, but there's no explicit when-to-use, when-not, or named alternative among the nine siblings.

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