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

Adds concrete behavioral detail beyond the annotations: caps of 5 posts per forum and 10 forums, plus fault tolerance ('a course or forum the school server will not open is left out and the rest still shows'). This resilience disclosure is genuinely useful and not derivable from readOnlyHint/openWorldHint.

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 the intent question and scoped limits before parameter guidance. The closing 'Ask: ...' sentence partly repeats the opening question, a small redundancy, but the rest earns its 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 single-optional-parameter read tool with annotations and no output schema, the description covers purpose, default scope, and partial-failure behavior adequately. Only minor gaps remain, such as ordering of results.

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 low, but the description compensates by explaining course_ids is optional and that omitting it covers all current courses, and the schema itself notes using get_my_courses to find IDs. It doesn't clarify accepted string-vs-number ID forms, a minor 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 ('Lists the latest news forum posts') with the exact fields returned (subject, course name, text), clearly distinct from all siblings like get_my_courses and get_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?

Explains the triggering intent ('any new announcements?') and clarifies course_ids is optional, defaulting to all current courses when omitted. It does not name any alternative or exclusion criteria, but no sibling tool overlaps with this purpose.

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 cover the read-only/open-world profile, but the description adds genuinely useful behavior: results are capped at 5 at a time, and attached files come back with the key stripped from the link so they are ready for get_file. It does not say how to retrieve the remaining assignments beyond the 5-item cap or what happens when the name filter matches nothing.

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 the user question it answers, then the return contents, then the inputs. Mostly economical, though the closing example question partly duplicates the opening framing and the assignment_name wording repeats the schema.

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

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

With no output schema, the description carries the return-value burden and does so: due date, instructions, file names and keyless links, plus the 5-item cap. Gaps remain around ordering of results when no name is given and empty-match behavior, but the essentials for a correct call are present.

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

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

Schema coverage is 100%, so both parameters are already documented. The description restates the same facts (course_id from get_my_courses, assignment_name as a name fragment) without adding new syntax, matching rules, or behavior for ambiguous matches. Baseline 3 is appropriate.

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

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

States a specific verb and resource with scope: it returns due date, instructions and attached files for assignments in one course, up to 5 at a time. The framing question 'what does assignment X require?' plus the explicit return fields make it clearly distinct from list-style siblings like get_assignments, and it names get_file and get_my_courses as related 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?

Gives concrete entry conditions: course_id must come from get_my_courses, and assignment_name (a name fragment) narrows to one assignment. It also shows a worked example query. It stops short of saying when NOT to use it, e.g. 'use get_assignments instead if you only need the list of 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 and openWorldHint, so the safety profile is covered. The description adds real value beyond that: a 25-item result cap and the exact set of possible submission statuses, neither of which appears in the schema. It doesn't explain what happens when the cap is hit or whether results are ordered by due date.

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 purpose statement is front-loaded and the limit/status detail follows efficiently. The trailing example question is somewhat redundant with the opening question framing, which is the only wasted 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 read-only, single-parameter list tool with annotations covering safety and no output schema, the description supplies enough: scope, cap, and status vocabulary. The only meaningful omission is whether a course with more than 25 assignments is truncated silently.

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 single course_id parameter is fully documented in the schema, including the pointer to get_my_courses. The description restates that pointer but adds no format or edge-case detail, 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 states a concrete verb and resource — 'Lists up to 25 assignments for one course with due dates and submission status' — and enumerates the status values. It implies the course-scoped niche versus sibling tools like get_missing_work or get_upcoming_due_dates but never names them explicitly, so differentiation is left to 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 frames the usage as a concrete question ('what do I still need to submit in this course?') and gives an example invocation, plus tells the caller to source course_id from get_my_courses. It stops short of stating when to prefer a sibling such as get_missing_work or get_todo, which would have earned 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 readOnly and openWorld, but the description adds real operational detail beyond them: a 50-event cap, a 366-day maximum window, oldest-first ordering, inclusive endpoints, and the fact that non-actionable events are included. These are exactly the limits an agent needs to avoid misreporting 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?

Dense but well front-loaded: purpose, scope, sibling contrast, then parameters. Minor waste in restating inclusive date bounds already covered by the schema, and the example question about 'what is due' slightly blurs the distinction between calendar events and due dates.

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 results and does so: course name and date, oldest first, capped at 50. Combined with the date-window limit and timezone note, an agent has everything needed to call it and interpret the 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 coverage is 67%, and the description fills the main gap by specifying the server's local time zone for the date strings and reiterating inclusive boundaries and the optional course_ids filter. It adds meaning beyond the schema but does not explain how course_ids behaves with multiple values or how to page past the 50-event cap.

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?

Opens with a concrete user question and states a specific verb and resource: lists up to 50 calendar events between start_date and end_date, oldest first, with course name and date. It explicitly differentiates itself from get_upcoming_due_dates and get_overdue, so an agent can route correctly 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?

Names the two alternative tools and the condition that selects this one: any dates, past or future, and events that need no action. The closing example ('What is due the week of Dec 1?') reinforces the trigger condition, leaving little 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?

Beyond the readOnly/openWorld annotations, the description discloses meaningful behavior: sections contain up to 40 activities, activity intro text is included when present, and file links have your key removed so they are safe to show in chat. That is exactly the kind of output and safety context annotations do not provide.

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 answer is front-loaded with the core question it addresses, then moves through sections, activities, files, input, and an example ask. Every sentence contributes useful selection or expectation-setting information, and the example is brief enough to justify 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?

There is no output schema, so the description carries the return-shape burden and does so well: sections, activities, intro text, files, and safe links are all explained. Annotations cover safety and openness, and the single required parameter is fully documented. Nothing an agent needs to call this correctly appears to be missing.

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

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

The only parameter is fully documented in the schema, including that it is the Moodle course ID found via get_my_courses. The description repeats the same source guidance but adds no syntax, format, or constraint details beyond the schema. With 100% schema coverage, this meets the baseline rather than exceeding it.

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

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

The description states a specific verb-and-resource purpose: listing sections and activities within one course, including files, with an explicit framing question. It distinguishes itself from file-opening tools by explaining that links are safe for chat and can still be opened with get_file. An agent can tell what this tool returns 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?

It clearly establishes the use case: answering what materials are in a course, with course_id sourced from get_my_courses. It also names get_file as the follow-up tool for opening file links. It does not explicitly exclude sibling tools such as get_course_page or get_assignments, but the context is clear enough for selection.

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

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

Annotations already cover readOnly and openWorld, so the description's job is to say what comes back. It does: per-item marks and percentages plus the course total when one exists, and the 'when there is one' hedge correctly signals that the total is conditional.

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 question framing front-loads the purpose, then input, then an example: three compact sentences with no filler. The quoted 'Ask:' example is slightly redundant with the opening question but still earns its place as a trigger.

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?

This is a single-parameter read tool with no output schema, so the description must carry the return shape, and it does by naming marks, percentages and the conditional course total. It lacks detail on ordering, empty-gradebook behavior or whether ungraded items appear.

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 says the course_id is a Moodle course ID found via get_my_courses. The description repeats that same guidance without adding format or type details, so the baseline 3 applies.

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

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

The description states a specific verb and resource: list every graded item for one course with mark and percentage. It implies a course-scoped scope that separates it from a global grades tool, but it never names get_my_grades or another sibling, so differentiation is inferential.

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 a concrete trigger question and an example prompt, plus explicitly routes the ID lookup to get_my_courses. It omits when-not-to-use guidance, e.g. how it differs from get_my_grades or get_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 only declare readOnlyHint and openWorldHint; the description adds substantial behavior beyond them: a 5-page cap, 20000-character per-page limit, the '[truncated]' marker, and the exclusion of images/embedded media. These are exactly the operational traits an agent needs to interpret output correctly.

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?

An effective lead sentence answers the core question, followed by scope, limits, inputs, and an example in a tight sequence. Every sentence carries distinct information (limits, exclusions, parameter sourcing) with no repetition of the schema.

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

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

With no output schema, the description still explains the return form (plain text, HTML stripped, truncation marker, no media) and the pagination-like cap, so the agent knows what it will get. Nothing needed for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3, and the description adds a little genuine meaning: page_name is a 'word or phrase from the page title' used to pick one page, and omitting it reads the first pages. It doesn't add format/syntax detail beyond the schema, so it stays just above 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?

The description uses a specific verb and resource ('Reads the Page activities of one course... returns their text') and scopes it to pages listed as 'page' in get_course_content, distinguishing it from get_file and get_course_content. An agent can tell immediately what this returns 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?

It explicitly states how to source course_id ('the ID from get_my_courses'), how page_name selects one page versus reading the first pages when omitted, and pairs it with a concrete invocation example ('Read the Week 2 reading page in Networking Basics'). Alternative behavior (omitting page_name) is spelled out rather than left 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?

Discloses the full outcome matrix — text/HTML returned as readable text, PDF with text extracted, PDF without text or unsupported types falling back to file name plus a redacted link and a Moodle note — which annotations (readOnlyHint, openWorldHint) do not cover. The security note that only links on the school's Moodle site are downloaded, so the key is never sent elsewhere, is valuable context beyond structured fields. No contradiction with 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?

Front-loads the core question and action, which is good, but repeats the same fallback clause ('file name, a link with your key removed and a note to open it in Moodle') three times and states supported types twice. The redundant sentences dilute an otherwise well-organized description.

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

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

For a single-parameter read tool with no output schema, the description covers the input's provenance, all supported and unsupported outcomes, the security boundary, and a usage example. An agent has everything needed to call it and anticipate what comes back.

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% with a single required parameter, so the baseline is 3; the description adds real value by specifying the parameter's origin ('the link from get_course_content') rather than any arbitrary URL. It does not add constraints such as whether the URL must be absolute or a Moodle-relative path, keeping it below a 5.

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 ('Downloads one course file resource, such as a PDF, slide deck or handout') and anchors it to a concrete user question. It implicitly distinguishes itself from get_course_content, which supplies the link rather than the content, so an agent can route between them 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 clear context ('Answers what does this course file say?'), names the upstream source ('the link from get_course_content') and provides a worked example ask. It stops short of an explicit when-not-to-use statement, e.g. 'use get_course_content to list files and this to read one,' but the sourcing instruction makes the split inferable.

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?

Beyond the readOnly/openWorld annotations, it discloses result caps (5 discussions per forum, up to 5 forums), announcement-forum filtering, and partial-failure behavior ('a forum the school server will not open is named at the end and the rest still shows'). It also lists the fields returned, so the agent knows what evidence it will get before calling.

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 body is front-loaded and dense with useful facts, but the example question 'What are people discussing in the Networking Basics forum?' is stated twice, once at the opening and again at the end, which is pure redundancy. The chatty question framing also delays the actual verb-and-resource statement.

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 listing tool with no output schema, the description covers inputs, selection rules, truncation limits, exclusions, returned fields, and degraded-response behavior. An agent has everything needed to call it correctly and to interpret a partial result.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only marginal meaning: it clarifies that forum_name selects a single forum via a partial-name match, but course_id provenance is already stated in the schema and no match semantics (case, ambiguity, multiple matches) are explained.

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 verb and resource ('Lists the latest discussions in the forums of one course') and enumerates the returned fields. It also distinguishes itself from get_announcements explicitly, so an agent can separate it from the closest sibling 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 clear context for use and one explicit exclusion ('Announcement forums are left out, use get_announcements for those'). It does not address the other obvious alternative, get_forum_posts, so the agent has no stated rule for choosing between reading a forum's discussion list and reading a discussion's posts.

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?

Beyond the read-only and open-world annotations, it discloses the single-discussion scope, returned fields, and limits of 50 posts and 2000 characters per post. It does not explain ordering, which posts are selected when a thread exceeds 50 posts, or whether additional pages can be retrieved.

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

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

The description is compact and front-loads the intended task, followed by behavior, input provenance, and an example. The opening quoted question and final example are somewhat redundant, but neither is excessively verbose.

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

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

For a simple one-parameter read tool without an output schema, the description supplies enough information to select it, obtain the required ID, invoke it, and anticipate the returned content and size limits. The remaining uncertainty about threads over 50 posts does not prevent 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 100%, and the description largely repeats that discussion_id comes from get_forum_discussions. Calling it 'the number' adds little and is slightly narrower than the schema's string-or-number type, though the schema makes the accepted input clear.

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

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

The description clearly states that the tool reads one forum discussion, including the first post and replies, and identifies the returned author, date, and text fields. This distinguishes it from get_forum_discussions, which supplies the discussion ID rather than reading the thread.

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 opening instructor-answer question and closing Lab 3 example provide a concrete use case, while the input sentence points agents to get_forum_discussions as the ID source. It does not explicitly say to discover the discussion first when the ID is unknown or clarify that this tool is not for listing or searching discussions.

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?

Beyond the readOnlyHint annotation it discloses real operational traits: drafts that were never handed in are included, handed-in/graded work is excluded, up to 25 assignments per course are checked, and results are capped at 50 items. Those inclusion/exclusion rules and truncation caps are exactly the kind of behavior an agent cannot get from annotations or 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?

Front-loaded with the intent question, then scope, exclusions, and limits in a logical order; every sentence carries information. The closing 'Ask: ...' line partially restates the opening question, a small redundancy.

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

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

For a read-only filter tool with no output schema, it covers inclusion rules, exclusions, per-course scan depth, result cap, and the fields returned (course name, due date). What is missing is what happens when the 50-item cap truncates — ordering or a truncation indicator — which matters for an agent summarizing results.

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

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

The schema's course_ids property lacks a top-level description (0% coverage), and the description compensates by explaining that the array limits the list and that omitting it covers all current courses. It does not repeat the schema's note that IDs come from get_my_courses, but the key default semantics are supplied.

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 ('Lists the assignments in your courses that you have not handed in yet') and adds an intent framing ('what do I still owe?') an agent can match a user request against. The scope definition (not-submitted, includes drafts) implicitly separates it from get_overdue and get_upcoming_due_dates, but 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 a clear trigger ('Ask: "What work am I still missing?"') plus the default behavior of omitting course_ids to cover all current courses, which is actionable selection context. It does not state when to prefer get_overdue, get_todo, or get_assignments instead, so the agent must infer the boundary.

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

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

Annotations already establish readOnlyHint and openWorldHint, so the description only needs to add context. It usefully adds that the call takes no input and returns current courses plus reusable course IDs, though it does not discuss ordering, hidden courses, or pagination.

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 question and followed by the return behavior and usage hint. There is 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?

For a zero-parameter read tool with no output schema, the description is complete enough: it states what is returned, that no input is required, and why the returned ID matters for other 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?

The tool has zero parameters, so the baseline is 4. The description reinforces this with 'No input,' which is consistent with the empty 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 specific verb and resource: it lists the current Moodle courses the user is enrolled in. It also distinguishes itself from siblings by explaining that the returned ID is the course_id other tools consume.

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 a clear triggering question and notes there is no input, and it explains the downstream use of the returned course ID. It does not explicitly compare against alternatives, but the usage context is clear.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful behavioral detail that missing grades yield 'no grade posted yet', which prevents an agent from misreading empty results. It does not describe return shape or ordering, but with annotations present the bar is lower.

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 purpose and scope are front-loaded in the first two sentences. The trailing sample question largely restates the opening line, which is mild redundancy rather than harmful, so the description stays short and readable.

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

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

For a zero-parameter, read-only lookup with no output schema and no nested objects, the description covers purpose, scope, and the empty-result behavior. Nothing an agent needs to call it correctly appears to be missing, though naming the item-level alternative would close the last gap.

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 is 4. The description correctly states 'No input', consistent with the empty schema, and adds no misleading parameter guidance.

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

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

The description names a specific verb/resource combination ('Shows the posted overall grade for every current course') and scopes it to overall per-course grades, which implicitly distinguishes it from the item-level sibling get_course_grade_items. It stops short of naming that sibling explicitly, so differentiation is left partly to 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?

Usage is implied through the repeated sample question ('What's my grade in each course?'), which tells the agent the triggering scenario. However, there is no explicit statement about when to prefer this over get_course_grade_items or get_assignments, and no exclusions 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?

Annotations already cover the readOnly/openWorld profile, and the description adds substantive behavior beyond them: the 45-day lookback window, the 'still need action' filter, and the shape of what comes back (course name plus due date). It stops short of saying how results are ordered or what an empty answer looks like, but the added context is real.

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 the question it answers, then the return shape, then the parameter — a logical order with little waste. The only flaw is redundancy: 'is anything overdue?' appears at the start and again as a closing 'Ask:' line, which earns nothing the first sentence didn't.

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-required-param read tool with no output schema, the definition supplies purpose, default scope, time window, and returned fields — enough to call it correctly and interpret results. Ranking/pagination behavior is unstated but unlikely to matter for this query 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?

With 0% reported schema description coverage on the parameter itself, the description carries the burden and does so: course_ids is identified as an optional array that limits the list, and the default (omit it → all current courses) is spelled out. The schema's item description adds the get_my_courses pointer, which the prose doesn't repeat — minor, but the essential semantics are covered.

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 question it answers ("is anything overdue?") and the resource it returns: past due items from the last 45 days that still need action, with course name and due date. That is concrete enough to separate it from get_upcoming_due_dates, but it never names or contrasts with the neighboring overdue/missing/todo tools, so sibling 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 does give a usable when-to-use cue ("Ask: 'Is anything overdue?'") and a scoping rule (omit course_ids to cover all current courses). However, it gives no exclusions or alternatives — nothing tells the agent why to pick this over get_missing_work or get_todo, which likely overlap.

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 goes further by disclosing the 25-item cap and enumerating exactly which fields come back (open/close dates, time limit, attempts used vs allowed, best grade). It does not say what happens with zero quizzes or whether the 25 cap can be exceeded, but the added behavioral context is substantial.

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 the user-facing questions, then the payload, then the input requirement — a sensible order with no filler. The second quoted example question largely duplicates the first sentence's prompts, so there is minor redundancy, but nothing bloated.

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, the description compensates by naming the returned fields and the 25-quiz ceiling, which is what an agent needs to decide whether the result is complete. Remaining gaps — empty-result behavior and pagination/truncation handling beyond the cap — are minor.

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 there is only one parameter, already documented as 'Moodle course ID. Use get_my_courses to find it.' The description restates the same guidance ('course_id, the ID from get_my_courses') without adding format or constraint detail, so the schema is doing the work and 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?

Opens with the concrete questions it answers (open date, attempts left, score) and then states the specific operation: listing up to 25 quizzes for one course with dates, time limit, attempt counts, and best grade. That is a precise verb+resource+scope. It does not differentiate itself from nearby siblings such as get_my_grades or get_course_grade_items, so it stops short of a 5.

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

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

The framing questions and the worked example give a clear sense of when this tool is the right call (quiz timing/attempts/score for a single course), and it names get_my_courses as the prerequisite for obtaining course_id. There is no explicit when-not-to-use or routing to the grade-oriented siblings, which keeps it at 4.

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 only declare readOnlyHint and openWorldHint, so the description usefully carries the behavioral load: it describes the output structure (Start here line, then ordered sections), the data sources (assignment list for submission status, calendar for quizzes), and the selection rule for the most urgent item. It stops short of noting failure modes, result limits, or auth requirements.

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 clause, and the section-ordering detail is useful. The long run-on sentence and the closing 'Ask: What should I do today?' echo the opening, a minor redundancy.

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

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

With no output schema, the description fully compensates by explaining the return shape, section order, and how the 'Start here' item is chosen. Combined with documented parameters, an agent has everything needed 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 67% and every parameter already has a schema description, so the description's per-parameter prose largely restates defaults (14/14). It does add mild value by clarifying that course_ids limits the digest scope and how the day windows are applied, but this is mostly redundant with 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 description states a specific purpose — a single cross-course digest answering 'what should I do today?' — and spells out its four sections (overdue, due soon, no due date, announcements). It implicitly distinguishes itself from siblings like get_overdue or get_upcoming_due_dates by being the aggregate, but never names those siblings explicitly, 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?

Usage context is clear via the framing question ('Ask: What should I do today?') and the described scope of the digest. However, there are no explicit exclusions or named alternatives telling an agent when to prefer get_overdue or get_announcements over this aggregate.

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?

Beyond readOnlyHint/openWorldHint, the description discloses the 50-item cap, 60-day window, soonest-first ordering, included fields (course name, due date), and the exclusion of course events. That is rich behavior context the annotations do not carry.

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 answer is front-loaded, with the purpose, scope, return shape, parameter behavior, and intent-routing example all in a compact sequence. Each sentence adds something an agent needs.

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 one optional parameter, no output schema, and read-only/open-world annotations, the description covers everything needed: result limits, time window, ordering, fields, exclusions, and default parameter behavior.

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 low, but the description compensates fully: course_ids is an optional array that limits the list, and omitting it covers all current courses. That adds meaning beyond the JSON schema, which only defines the array type.

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

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

The description states a specific verb and resource ('Lists up to 50 items due in the next 60 days') with scope, ordering, and exclusions, so an agent can distinguish it from siblings like get_overdue or get_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 context via the 'what is due soon?' framing and the 'still need action' filter, and explicitly excludes course events. It does not, however, name alternative tools such as get_overdue or state when not to use this one.

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