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

Annotations already declare readOnlyHint and openWorldHint, and the description adds the key behavioral fact that the result is an ICS file meant for calendar import, plus the default scope of all active classes when no filter is given. It omits anything about time range covered by 'upcoming' or file size/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?

Three short sentences, output artifact first, filtering second, triggering user phrasing last — every sentence carries information and nothing is padding.

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 present, the description correctly identifies the returned artifact as an ICS file, and both optional filters are covered by the schema. Only the meaning of 'upcoming' (the date window) is left unspecified.

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 100%, so both parameters are already documented, including the get_my_courses hint and the name-matching behavior. The description only restates the course_ids scoping and default, and never mentions course_name, so it adds little beyond the schema baseline.

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

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

States a specific verb and artifact ('Build an ICS calendar file of upcoming due dates'), which cleanly separates it from siblings like get_upcoming_due_dates that return raw date data rather than an importable file.

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 an explicit trigger ('Use this when the user asks... as a calendar file?') and states both scoping modes. It does not name the nearest alternative (get_upcoming_due_dates), so an agent must infer that the file-export intent is the deciding factor.

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 usefully adds that results link back to Classroom and that the default scope is all active classes, but says nothing about result volume, pagination windows, or auth requirements beyond what the schema's offset text implies.

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

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

Two sentences, front-loaded with what the tool returns, followed by filtering guidance and use-case triggers. The quoted example questions cost some length but serve the routing decision; nothing is redundant enough to penalize.

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?

A simple read-only list tool with fully described parameters and annotations; the description covers output shape and scoping, which is sufficient. Minor gap: no mention of the 15-classes-per-page reading behavior that the schema hints at, which would matter for an agent planning retrieval.

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 all three parameters (course_ids, since_days, offset) are already documented, including the offset pagination hint. The sentence about course_ids/since_days reinforces the filtering defaults but adds little beyond the schema, which sets the baseline at 3.

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?

Names the specific resource (announcements) and states what each item contains (a link to open it in Classroom), which is enough to distinguish it from siblings like get_course_materials or get_whats_new. It never uses a direct verb like 'list' or 'fetch', so the operation is inferred rather than stated.

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 concrete usage conditions via example user questions ('Did my teacher post anything new?') and explains the filter choices: pass course_ids or since_days, or leave empty for all active classes. It does not name an alternative sibling tool or state when NOT to use it, so it stops short of the top score.

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 safety is covered; the description adds value by disclosing the returned payload (description body, attachments, due date, points, personal status), which matters since there is no output schema. It does not cover error behavior, permissions, or what happens with an invalid ID.

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

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

Three sentences, front-loaded with the capability, then the payload, then the invocation and usage triggers. No sentence is filler; the usage examples do real routing work.

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 full schema coverage and annotations covering the safety profile, the description supplies the remaining pieces an agent needs: what is returned, how to call it, and when it applies. Nothing material 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 is 100% and the schema already documents both parameters, including pointers to get_my_courses and get_assignments for lookup. The description only restates 'Pass the course ID and the assignment ID', adding no format or type guidance beyond the schema, 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?

States a specific verb and resource ('Everything about one assignment') and enumerates exactly what is returned: description text, attachments/links, due date, points, and submission status. This is clearly distinguishable from sibling list tools like get_assignments or get_upcoming_due_dates.

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 concrete triggering user questions ('What does this assignment ask for?', 'What do I need to turn in?') and scopes usage to 'one specific assignment', which implicitly separates it from the list tools. It never names an alternative sibling explicitly or states a when-not condition, so it falls 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds useful disclosure about what comes back (due dates, status, deep link), which matters because there is no output schema, but says nothing about behavior on an ambiguous course_name or an unmatched class beyond what the schema already states.

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, front-loaded with the resource and scope, then the usage trigger. 'Single class' appears twice but the repetition reinforces the key constraint rather than wasting space.

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

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

For a two-parameter read tool with no output schema, the description tells the agent what selector to use, what the results contain, and when to reach for it. Nothing essential to a correct call 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 is 100% and both parameters are documented in the schema, including case-insensitive partial matching and the exactly-one-match rule. The description only restates the either/or choice, adding no syntax or matching nuance of its own, so 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?

Names a specific resource (assignments) and scopes it to exactly one class selected by course_id or course_name, which separates it from get_assignment_details (one assignment) and get_todo/get_upcoming_due_dates (cross-class lists). It does not name those siblings explicitly, so the differentiation is inferred from scope rather than stated.

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 concrete trigger phrase ('What's due in this class?') and the intent 'every assignment and its points for a single class', which is a usable selection rule. It stops short of stating when NOT to use it, e.g. across all classes or for a single assignment's detail.

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 and openWorldHint, so the safety profile is covered. The description adds real behavioral value: results are grouped by topic and every attached file exposes a Drive link, which tells the agent what it will actually receive. It does not say what happens when no materials are posted or when a course name is ambiguous, though the schema covers the latter.

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?

Front-loaded with what the tool returns, then when to use it. The quoted example questions are a bit padded, but each one maps to a distinct phrasing an agent might encounter, so they mostly earn their space.

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

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

With only two optional params, no output schema, and read-only annotations, the description covers purpose, invocation route, and return shape. The main remaining gap is edge-case behavior (empty material lists, ambiguous course names), which is partly handled in the 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?

Schema description coverage is 100% and the schema already explains that either course_id or course_name suffices, that name matching is case-insensitive, and that it must resolve to exactly one active class. The description only restates 'picked by course_id or course_name', adding no new selector semantics, so 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?

States a specific verb+resource (fetch posted materials for one class) plus how results are organized: grouped by topic with the Drive link of each attached file. That output shape plus the course_id/course_name selector distinguishes it cleanly from siblings like get_assignments or get_announcements.

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 concrete trigger phrasing ('What materials did my teacher post?', 'What did we cover in unit 3?') and names the content types it covers (readings, slides, handouts). It lacks an explicit when-not or a direct pointer to a competing sibling, which keeps it below 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered; the description adds the meaningful caveat that email addresses only appear when Classroom shares them, and that results are grouped per class rather than flattened. It does not mention pagination or result ordering, though the schema's offset field covers paging.

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 paragraph is front-loaded with what is returned, then how to scope the call, then when to reach for it, with no filler sentences. The quoted user phrasings are slightly verbose but earn their place as selection cues.

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 carries the burden of describing returns and does so (per-class lists, email addresses conditionally included). Selection semantics, defaults, and the sharing caveat together are sufficient for a read-only four-parameter lookup 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 coverage is 100%, so the baseline is 3, and the description adds genuine relationship semantics: course_id targets one class while course_ids/course_name target many, and an empty selection means all active classes. It does not, however, explain how course_name matches are resolved beyond what the schema already states.

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 opening clause names a specific resource (teachers of your classes) and the payload (email addresses, when Classroom shares them), which distinguishes it from sibling list tools such as get_my_courses or get_assignments. An agent can tell immediately that this returns instructor identities rather than course metadata.

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 explicitly covers all three selection modes (course_id for a single class, course_ids or course_name for several, and no argument for all active classes) and adds concrete user phrasings ('Who teaches this class?', 'How do I email my teacher?') that trigger the tool. Exclusion conditions are implicit in the mode breakdown, but the routing instruction for course_name versus get_my_courses is explicit.

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?

readOnlyHint=true and openWorldHint=true already tell the agent this is a safe, open read, so the description only needs to add context. It adds the 'active classes' scope but does not mention that results are read 15 classes at a time or what a result row contains.

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 short sentences, front-loaded with the core definition, then filtering, then usage triggers. The quoted user questions consume space but serve routing, so nothing is clearly wasteful.

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 full schema coverage and clear annotations, an agent has enough to call it correctly. The missing piece is any hint at the return shape (course, assignment, due date), which matters more because there is no 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?

Schema description coverage is 100%, so offset, course_ids and course_name are fully documented already. The description restates the course_ids empty-vs-populated behavior without adding format or syntax detail, 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?

States a specific resource and a precise filter condition: past due work that has not been turned in. That definition naturally separates it from get_todo and get_upcoming_due_dates, though no sibling is named 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?

Gives concrete user phrasings that should trigger it ('What's overdue?', 'What am I behind on?') plus the scoping rule (pass course_ids to limit, leave empty for all active classes). It stops short of naming the alternative tools for adjacent questions like upcoming work.

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 one real behavioral detail beyond that: the list is limited to 'active' classes, implying archived/inactive courses are excluded. It says nothing about ordering, pagination, or how 'active' is determined, so the added context is modest.

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, no filler, and the core purpose is front-loaded before the usage hint. Every clause carries information an agent would otherwise have to infer.

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 tool with readOnly/openWorld annotations, this is sufficient: the description covers what is returned (courses plus IDs), the scope (active), and the reason to call it. No output schema exists, but the return content is characterized well enough 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?

The tool takes zero parameters, so there is no parameter semantics to explain and the baseline of 4 applies. The phrase 'with their IDs' usefully describes the payload shape rather than any input.

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

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

States a specific verb ('List') plus the exact resource ('the student's active Google Classroom classes') and the key returned field ('their IDs'). This is clearly separable from siblings like get_assignments, get_my_grades, or get_course_materials, which operate on content within courses rather than the course roster itself.

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 concrete trigger ('What classes am I in?') and a downstream reason to call it ('needs a course ID to pass to another tool'), which is exactly the routing signal an agent needs. It stops short of naming an explicit alternative or a when-not condition, so it lands just below the top band.

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 adds meaningful behavioral context beyond the readOnlyHint annotation: it explains that only returned work is counted, that Google Classroom has no overall grade, and that weighted percentages are calculated when grading categories exist. It does not cover authentication, rate limits, or return formatting details, but it discloses the key aggregation 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?

The description is front-loaded with the tool's purpose and calculation behavior, then moves to parameter guidance and example usage. Every sentence contributes relevant information without unnecessary repetition.

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

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

Given the absence of an output schema, the description does a good job explaining that results include per-class grades, teacher comments, and weighted percentages. Completeness is slightly limited because it does not describe edge cases such as classes with no returned work or the exact response shape.

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 all three parameters are already documented in the schema. The description reinforces course_ids behavior but does not add new meaning for course_name or offset beyond what the schema already provides.

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 resource and scope: grades on returned work per class, including teacher comments and weighted percentages. It is specific enough to distinguish the tool from general assignment or course tools, but it does not explicitly name or contrast with close siblings like get_target_grade or get_missing_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?

It gives clear usage context with example user questions ('How am I doing in my classes?') and explains how course_ids can limit results. However, it does not state when not to use this tool or name alternative tools for related grade questions.

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 beyond that by enumerating the returned data points (turn-in state, timestamp, lateness, grade, teacher comment), which matters because there is no output schema. It omits what happens when no submission exists, a modest gap.

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

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

The leading question orients the reader immediately, followed by scope, parameters, and triggers in a logical order. The phrase 'Did my teacher get my work?' appears twice (opening and usage example), which is mild redundancy but not harmful.

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 lookup with no output schema, the description covers purpose, inputs, and the shape of the result, which is sufficient to invoke correctly. It could be more complete by noting behavior when the assignment has no submission record.

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% and both parameters already point at the discovery tools (get_my_courses, get_assignments). The description's 'Pass the course ID and the assignment ID' merely restates the required inputs without adding format or edge-case meaning, 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?

Names a specific resource and scope — 'For one assignment, shows whether it is turned in, when it was turned in, whether it was late, the grade... and the comment' — which is exactly what the tool returns. The single-assignment scope implicitly separates it from list-style siblings such as get_missing_assignments and get_todo, so an agent can place it without opening the 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 concrete trigger phrasings: 'Use this when the user asks "Did my teacher get my work?" or "Was my assignment marked late?"' That is clear when-to-use context. It does not name alternatives (e.g., get_missing_assignments for a whole-course view) or state when not to use it, which keeps it 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful behavior: it explains the arithmetic behind the answer and notes that up to 15 classes are read per call (the offset parameter's schema text carries the pagination detail). It doesn't cover edge cases such as classes with no graded work or ungraded categories.

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 core purpose is front-loaded in the first sentence, and the mechanism sentence plus the example questions earn their place. Slightly long, with minor redundancy between the mechanism sentence and the target_percent restatement, but 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?

There is no output schema, so the description must carry the return-value burden; it does say the result is a per-class count of points still needed, which is the key shape. It stops short of describing all returned fields (e.g., current percent or points already earned), leaving a small gap for a computation tool.

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

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

With 100% schema description coverage, the schema already documents offset, course_ids, course_name, and target_percent in detail. The description restates target_percent's 0-100 range and the course_ids scoping rule but adds no new semantic meaning, and it never mentions course_name or offset, so 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 names a specific computation and resource: 'Points needed on the work that is left to reach a target percent in each class,' and explains the mechanism (points earned plus points remaining). This implicitly separates it from get_my_grades, but it never names that sibling explicitly, so differentiation relies on inference.

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 concrete triggering conditions via example user questions ('What do I need to score to get a 90?', 'Can I still get an A in this class?') and clarifies scoping behavior for empty course_ids. It also notes that course_name exists so you can skip get_my_courses, but it doesn't state when NOT to use this tool.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds one useful return detail (each item carries a Classroom link) and the course_ids scoping behavior. It says nothing about ordering, result volume, or the 15-class pagination behavior that the offset parameter implies, so the added context is modest.

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, front-loaded with what the tool returns, then parameters, then user-facing triggers. The course_ids sentence duplicates the schema and could be dropped, but overall it is tight and purposeful.

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, zero-required-parameter listing tool with a fully documented schema and no output schema, the description covers what is returned (unfinished items plus links) and how to scope it. The main remaining gap is expected result volume and ordering, which matters for an agent planning a response.

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

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

Schema description coverage is 100% and every parameter is documented in detail, including the 15-class paging semantics and the case-insensitive course_name matching. The description only restates that course_ids limits scope and empty means all active classes, adding no meaning beyond the schema. 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 states a specific resource and scope: everything assigned but not turned in, with a link to open it in Classroom. That is clear enough to act on. It does not, however, distinguish itself from the close sibling get_missing_assignments or get_upcoming_due_dates, which an agent would plausibly confuse it with.

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 concrete trigger phrasing ('What do I still have to do?', 'What's left to turn in across all my classes?'), which anchors usage well. It offers no when-not-to-use guidance or pointer to the overlapping siblings, so the routing decision is only half covered.

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 supplied, the description adds useful behavior: results are ordered soonest-first and exclude turned-in work. It says nothing about the 15-class pagination cap or the shape of the returned list beyond the ordering, leaving meaningful gaps.

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

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

Three short sentences, front-loaded with the core definition followed by filtering and usage examples. The structure is easy to scan; the example questions are justified because they anchor intent matching.

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, and the description does not say what each result contains (course, assignment name, due date) or that reads are capped at 15 classes. For a list tool whose output shape must be inferred, this is adequate but incomplete.

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

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

Schema description coverage is 100%, so the parameters are already fully documented, and the baseline of 3 applies. The description reinforces that course_ids and days_ahead narrow the result and are optional, but omits course_name and offset, adding little meaning 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?

The first sentence names a specific resource and filter ('Work that is due soon and not turned in, soonest first'), which tells an agent exactly what this returns. It lacks explicit differentiation from siblings like get_todo and get_missing_assignments, which overlap conceptually, 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?

It gives concrete example user phrasings ('What's due this week across all my classes?') and states that filters are optional, which sets clear usage context. It does not say when to prefer get_todo or get_missing_assignments instead, so alternatives are left 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 and openWorldHint, so the safety profile is covered. The description contributes real behavioral content: that results are aggregated into one digest per class and that graded items carry the teacher's comment, which is not derivable from annotations or schema. It does not mention pagination or result volume, though the schema documents the 15-class page size via offset.

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 of purpose followed by one sentence of parameter scoping and one of usage triggers, with the digest contents front-loaded. No filler and 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 an all-optional, read-only aggregation tool with no output schema this covers what is aggregated, how to scope it and when to reach for it. The remaining gap is pagination behavior — the digest reads 15 classes at a time, which matters for a multi-class teacher but is only discoverable in the offset field.

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 every parameter is already documented including defaults (7 days back, 14 days ahead) and the course_name matching rule. The description only restates course_ids/since_days/days_ahead at a higher level and never mentions offset or course_name, so it adds little 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?

States a concrete deliverable — a single catch-up digest per class containing new announcements, newly graded work with the teacher's comment, overdue items and upcoming due work. That composition immediately separates it from the narrower siblings (get_announcements, get_my_grades, get_missing_assignments, get_upcoming_due_dates), so an agent can pick it without opening a 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 explicit trigger phrases ('What's new since yesterday?', 'What changed in my classes?') and explains how to narrow scope via course_ids, since_days and days_ahead. It stops short of naming the sibling tools it replaces for narrower questions, so an agent has to infer that distinction rather than being told.

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