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

Annotations already declare readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the description's job is to add context — and it does: the write is confined to an 'encrypted local baseline' and no alerting/scheduling occurs. It still doesn't say what happens on the first run with no baseline, or where the baseline lives.

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

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

A single compact sentence with the core action front-loaded and the two caveats (local-only write, no alerts) trailing. It is terse rather than padded, though the clause structure is slightly compressed to the point of ambiguity about 'previous check'.

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?

An output schema exists, so return values need not be described, and the comparison scope plus non-alerting behavior are covered. However, the stateful 'previous check' concept — first-run behavior, baseline persistence, scope of the diff — is left unexplained, which matters for a non-idempotent stateful tool.

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

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

Schema description coverage is 0% for the single required course_id, and the description never references it or explains its format/source. With one undocumented parameter the description must compensate and instead says nothing, so the agent gets no guidance beyond the bare name.

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

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

States a concrete verb (Compare) and enumerates the compared resources (course materials, assignments, notices) against a previous check, which cleanly separates it from siblings like plms_weekly_brief or plms_compare_syllabus. It never names a sibling explicitly, so an agent must still infer which change-detection tool to pick.

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

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

'with previous check' implies the tool is for diffing against stored state, and 'No scheduled alerts' rules out one adjacent use case. But no alternative is named (e.g., when to prefer plms_weekly_brief or plms_compare_syllabus), and prerequisites such as needing a prior run are only implied.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so safety is covered. The description adds genuinely new behavioral context: that caller-supplied observations are hypothetical and never authoritative records, which tells the agent how input is weighted. It stops short of describing the comparison output, though an output schema exists to carry that.

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

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

Two tight sentences, front-loaded with the comparison action, followed by the one caveat that matters about input trust. No filler, nothing repeated from the schema or annotations.

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?

An output schema exists, so return values need not be described, and the safety profile is covered by annotations. What remains thin is the semantics of the observations parameter and the absence of any pointer to the single-source tools an agent might otherwise pick.

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

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

Schema description coverage is 0%. course_id is self-explanatory, but observations is an opaque array of free-form objects, and the description only gives its epistemic status (hypothetical, non-authoritative) without shape, contents, or expected keys. That partially compensates for the missing schema text but leaves real ambiguity.

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 (compare) and two concrete resources (syllabus rules, LMS deadlines and attendance evidence), which clearly separates it from single-source siblings like plms_get_syllabus and plms_get_attendance. It doesn't explicitly name those siblings, so routing 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?

The description implies the scenario (comparing syllabus rules against actual LMS data) but never says when to use this tool rather than plms_get_syllabus, plms_upcoming_deadlines, or plms_get_attendance. No prerequisites, no exclusions, no alternatives named.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds useful scope detail by naming categories of returned content (restricted and upcoming items), but says nothing about auth requirements, pagination, or scope 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?

A single front-loaded sentence with no filler or redundancy. It is efficiently sized, though the enumerated list reads slightly like a dump of fields rather than a prioritized statement of purpose.

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?

Because an output schema exists, return-value detail is not required. Still, for a tool sitting among many near-duplicate siblings, the definition omits the usage context and parameter meaning an agent needs to select and 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?

The single required course_id parameter has 0% schema description coverage, and the description never mentions it or explains what a course_id is or where it comes from. With low coverage the description is expected to compensate, and it does not.

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 clear verb ('Read') and enumerates the resource's contents (weekly activities, materials, restricted/upcoming items, navigation), so an agent can tell it returns a course outline. However, it does not differentiate itself from overlapping siblings such as plms_list_assignments, plms_weekly_brief, or plms_get_syllabus, which plausibly return similar material.

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

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

There is no explicit when-to-use guidance, no exclusions, and no named alternatives among the many closely related PLMS tools. The agent must infer the intended context entirely from the name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and idempotentHint=true, so safety is covered. The description's 'no calendar account is modified' clarifies that this is an export rather than a sync to an external calendar, which is a small but genuine addition; it says nothing about the deadline window or scope.

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

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

A single front-loaded sentence with zero waste; the core action and the key non-effect are stated immediately.

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?

An output schema exists, so return values need not be described, and annotations carry the safety profile. Still, for a tool with two fully undocumented parameters and a close sibling, the description leaves the agent short of what it needs to call it correctly.

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

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

Schema description coverage is 0% and neither parameter is mentioned in the description. The 'days' window and the optional 'course_id' filter are entirely undocumented, so an agent cannot know the export horizon defaults to 30 days or that results can be narrowed to one course.

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

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

States a specific verb and resource ('Return an ICS calendar of known upcoming deadlines') and the output format (ICS), which is meaningful. It does not, however, distinguish itself from the very similar sibling plms_upcoming_deadlines, so an agent must guess which to call.

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

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

There is no when-to-use guidance and no mention of the near-identical alternative plms_upcoming_deadlines. The agent gets no criterion for choosing this tool over that sibling, nor any prerequisite information.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered. 'Never submits' adds a domain-specific confirmation that the tool cannot perform a write action despite the assignment context, but there is no mention of auth requirements, pagination or rate limits.

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

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

A single compact sentence with the read scope front-loaded and the negative constraint last. No filler and nothing redundant.

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

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

An output schema exists, so return values need no explanation, and annotations cover the safety profile; the description's enumeration of returned fields is adequate. The only real gap is not pointing to how an assignment_id is obtained.

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

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

Schema description coverage is 0% and the description never mentions the sole assignment_id parameter. Since assignment_id is a self-explanatory integer identifier, the schema's type is likely sufficient, but the description adds no guidance on where the ID comes from.

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

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

States a specific verb ('Read') and resource (assignment) and enumerates the content returned: instructions, submission/grading status, deadline, attachment links. This is clearly distinguishable from the sibling list tool plms_list_assignments and from other getters like plms_get_notice.

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 (fetch details for one assignment, given the required assignment_id) and the closing 'Never submits' functions as a when-not boundary. However, it never names an alternative such as plms_list_assignments for discovering IDs or states prerequisites, so guidance remains inferential.

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

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

Annotations already establish readOnly, idempotent, non-destructive, openWorld behavior, so the safety profile is covered. The description adds one genuinely useful data-state caveat — that future/unprocessed records read as 'unknown' — which is not derivable from annotations, but it says nothing about auth needs, refresh/staleness, or result shape.

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

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

Two very short sentences, front-loaded with the primary action and then the data-state caveat; nothing is padded. Slight ambiguity from the 'and/or' phrasing keeps it from a 5.

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

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

The tool is a simple two-parameter read, an output schema exists so return values need no explanation, and annotations carry the safety profile. The description covers purpose, the kind values, and a behavioral caveat; only the course_id reference and any caller-side context are left implicit.

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

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

Schema description coverage is 0%, and the schema defines no enum for 'kind' despite offering a default of 'both'. The description rescues this by enumerating the accepted values ('online', 'offline', 'both'), which is real added meaning, but it leaves 'course_id' semantics entirely undocumented.

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

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

The description gives a specific verb ('Read') and resource ('online learning progress and/or offline attendance'), which is more informative than the bare tool name. It does not, however, contrast itself with adjacent siblings like plms_get_grades or plms_course_outline, so the agent must infer the boundary.

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

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

There is no statement of when to call this tool versus alternatives, no prerequisites, and no exclusions. The parenthetical enum values describe a parameter, not usage context, so guidance is effectively absent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds two genuinely useful behavioral notes beyond that: grades are filtered to what is "visible" to the user, and the running total must not be mistaken for the final course grade. It says nothing about whether feedback may lag or how current the data is.

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

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

Two short sentences, zero filler, with the core action front-loaded and the interpretation caveat in second position. Nothing could be cut without losing 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?

An output schema exists, so return-values documentation is not required, and the annotations cover the safety profile. What remains missing is any linkage between the tool and its required course_id argument and how it relates to sibling tools that surface courses. Adequate but with clear gaps for a single-required-parameter tool.

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

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

Schema description coverage is 0% and the single parameter (course_id, integer) is never mentioned in the description. Nothing clarifies that grades are scoped to one course, or how course_id is obtained (e.g., from plms_list_courses). With one undocumented parameter, the description fails to compensate for the coverage gap.

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

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

States a specific verb+resource ("Read this user's visible grades and feedback") that is clearly distinct from siblings like plms_get_attendance or plms_get_assignment. It does not explicitly name or rule out any alternative tool, so it falls short of a 5. Still, an agent can identify the resource 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?

There is no statement of when to use this tool versus alternatives such as plms_course_outline or plms_get_assignment, nor any prerequisites. The only guidance offered concerns interpreting the result, not selecting the tool. Usage is left entirely to inference from the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered. The description adds that the body and attachments are returned in full, but says nothing about attachment retrieval mechanics, payload size, or pagination. Adequate but not rich given how much the annotations already 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?

One sentence, front-loaded with the action and resource, with the sourcing constraint appended. Every clause earns its place and 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?

An output schema exists, so return-value detail is unnecessary, and the description covers the essential scope (body plus attachments) for a two-parameter read tool. The only gap is the 0%-documented parameter distinction, which is a schema-level rather than description-level shortfall.

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

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

Schema description coverage is 0%, so both integer parameters (board_id, article_id) are undocumented in the schema. The description compensates partially by stating the IDs come from list_notices, but it does not distinguish board_id from article_id or explain why both are required.

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

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

States a specific verb (read) and resource (an announcement's full body and attachments), and explicitly contrasts with the sibling plms_list_notices by noting the IDs come from there. An agent can distinguish this full-content fetch from the list operation 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?

The phrase 'using IDs returned by list_notices' establishes the prerequisite workflow (list first, then fetch) and points to the correct alternative for enumerating notices. There is no explicit when-not guidance, but the ordering constraint 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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds only the 'with evidence' provenance hint, which suggests citations but is not explained; no auth, rate-limit, or scope details are given. With annotations carrying the load, this is adequate but thin.

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

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

A single compact sentence with the verb and resource front-loaded and no filler. The enumerated content list is slightly listy but each item earns its place by telling the agent what the call returns.

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?

An output schema exists, so the description needn't explain return values, and the enumerated content plus the read-only annotations cover the essentials of a one-parameter read tool. The missing course_id semantics and any when-to-use routing are the residual gaps.

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

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

Schema description coverage is 0% and the description never mentions the required course_id parameter, its expected format, or where to obtain it. For a single required param the meaning is guessable, but the description compensates for none of the coverage gap.

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

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

States a specific verb ('Read') and resource ('syllabus') and enumerates the content returned — grading rules, contacts, office hours, uploaded syllabus files. It does not distinguish itself from the sibling plms_compare_syllabus, leaving the agent to infer the boundary between reading and comparing.

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

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

No when-to-use guidance, no prerequisites, and no named alternative for related needs like comparing syllabi. The only signal is the implied 'read the syllabus' context; the agent gets no help deciding between this and plms_compare_syllabus or plms_course_outline.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds only a hint about returned columns (redundant with the output schema) and says nothing about pagination, ordering, 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?

A single front-loaded sentence with no filler; the key resource and returned fields appear immediately. It is arguably slightly too terse, 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?

With an output schema present, return values need not be explained, yet the description still repeats output columns instead of covering gaps like paging, ordering, or how course_id scoping works. Adequate but with clear omissions for a list tool operating in an open-world context.

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

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

Schema description coverage is 0% and the single required parameter course_id is never mentioned in the description. However, a lone integer named course_id is largely self-explanatory, so the description neither strongly compensates nor badly misleads. Baseline for a single obvious param is a 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?

States a specific verb ("List") and resource ("assignments") and even enumerates the columns returned (closing times, submission confirmation, raw grades). It is distinguishable from the singular plms_get_assignment, though it never names siblings or scope (course-level) 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?

There is no when-to-use or when-not-to-use guidance. The agent must infer that this is the bulk-listing counterpart to plms_get_assignment and is distinct from plms_upcoming_deadlines, but nothing in the text says so.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds a workflow hint (returned IDs feed other tools) but says nothing about the include_past behavior or the shape of the returned cards.

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

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

Two short sentences that are front-loaded with the purpose and add a follow-up routing hint. Nothing is wasted or padded.

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?

An output schema exists, so return values need no explanation, and the description is complete enough for a simple read-only listing tool. The only gap is the undocumented include_past parameter, which slightly under-specifies the call surface.

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

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

Schema description coverage is 0% and the single parameter include_past is never mentioned in the description. The tool's own text gives no indication that the returned set can be widened to past enrollments, leaving the agent to infer it from the bare boolean name.

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

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

States a specific verb and resource — 'List the current user's enrolled course cards' — scoped clearly to the current user. It does not explicitly differentiate itself from siblings like plms_list_assignments or plms_search, but the resource is unambiguous.

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

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

'Use returned course IDs for other tools' implies this is a discovery/entry-point tool that feeds downstream calls, which is useful context. However, there is no explicit when-to-use or when-not-to-use guidance versus alternatives such as plms_search or other listing tools.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely useful context beyond them: results are titles only (not bodies) and are paginated, which prevents an agent from expecting full content in one call.

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

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

A single compact sentence with the primary action and scope front-loaded, followed by the omission rule and the body caveat. No filler and nothing redundant.

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

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

With an output schema present, return-value detail is not required; the description appropriately focuses on scope and the titles-vs-bodies distinction. The only shortfall is the unelaborated page parameter, which is minor for a two-parameter read 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 0%, so the description must carry the load. It explains course_id's optionality and its site-wide semantics, but says nothing about the page parameter beyond the generic word 'pagination' (no indication of page size or ordering), leaving one of two parameters weakly specified.

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) and resource (course announcement titles) plus scope (with pagination, site-wide when course_id omitted). It also implicitly differentiates from plms_get_notice by noting that bodies must be read separately, though it does not name that sibling explicitly.

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

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

Gives a clear usage condition: omit course_id to get site-wide notices instead of course-scoped ones. It also signals that this tool is for titles and that body retrieval belongs elsewhere, but it does not name plms_get_notice as the alternative, leaving a small inference step.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld, so the safety profile is covered. The description adds a genuinely non-obvious behavioral fact beyond those hints: this call does NOT play videos or record viewing progress, which matters for stateful LMS tools. It omits auth/rate-limit context, but that gap is minor against the existing annotations.

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

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

One compact sentence with no padding, and the key differentiator ('without playing videos or recording progress') sits in the same breath as the action. It is dense but front-loaded and earns its length.

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?

An output schema exists, so return-value explanation is not required, and annotations carry the safety profile. What remains missing is routing guidance against the large set of sibling tools and any hint about the required course_id, leaving the definition minimally viable rather than complete.

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

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

Schema description coverage is 0% and the single required parameter (course_id) is undocumented in both schema and description. With low coverage the description is expected to compensate, and it adds nothing about where course_id comes from, its format, or scope (single vs multi-course).

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

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

The verb is clear ('Read') and it names the data surfaces returned (video descriptions, attendance, late deadlines), but it never explicitly frames itself as listing the online lectures of a given course. The mention of 'attendance' and 'late deadlines' also overlaps conceptually with sibling tools like plms_get_attendance and plms_upcoming_deadlines, so an agent cannot easily tell them apart from the description alone.

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

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

The clause 'without playing videos or recording progress' implies a use case (passive inspection that won't mark lectures as viewed), but there is no explicit when-to-use statement and no named alternatives among the many siblings. The agent is left to infer the routing decision itself.

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 safety profile (readOnly, idempotent, non-destructive, open-world), so the description adds genuinely new context: 'No OCR' discloses a capability limit, and 'without executing it' reassures about archive handling. It also names the return payload ('source locators and next_offset'). This is solid value beyond the annotations.

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

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

Four tight sentences, front-loaded with the formats and core action, then the archive edge case, then the return note and the OCR caveat. Every sentence adds distinct information with no 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?

An output schema exists, so return values need not be spelled out, and annotations cover safety. The main gap is pagination semantics (limit/offset) and the meaning of the two URL parameters, which an agent would need to call it correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden. It clarifies archive_member's role and ties source_url to the attachment link, and 'next_offset' hints at pagination, but limit, offset, and attachment_url are left entirely undefined. Partial compensation only.

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

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

States a specific verb (read) and resource (attachment) plus the exact supported formats (PDF, DOCX, PPTX, XLSX, HWP/HWPX, HTML/text), which clearly distinguishes it from plms_read_page in the sibling list. An agent can tell this handles file attachments rather than HTML pages 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?

Provides conditional guidance for the archive case ('ZIP lists members; set archive_member to read one without executing it') and a clear limitation ('No OCR'), but never states when to choose this over plms_read_page or what source_url vs attachment_url mean in practice. Usage is implied rather than explicitly routed against alternatives.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds a real behavioral boundary not present in the annotations: it refuses video playback and quiz-attempt routes, which tells the agent what this tool will reject.

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

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

Two tight sentences with the read scope front-loaded and the exclusion immediately after. Nothing is padded, though "strict read routes" is jargon that would benefit from one clarifying clause rather than being terse for its own sake.

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?

An output schema exists, so return-value explanation is not required. Still, for a URL-driven tool with limit/offset parameters, the description omits how to recognize truncation or continue a paged read, which is the main operational 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?

Schema description coverage is 0% and the description says nothing about any of the three parameters. The presences of limit (default 16000) and offset (default 0) strongly imply paged/truncated reads, but neither the truncation behavior nor the expected url format is explained anywhere.

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

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

States a specific verb (read) and enumerates the resource types it covers (resource/folder/page/quiz metadata/board/calendar), so an agent knows what it returns. It is distinguishable from siblings like plms_get_grades or plms_get_notice by being the generic URL-driven reader, though it does not name those siblings 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?

"Strict read routes only; no video playback/quiz attempts" gives a partial exclusion, which is more than most siblings offer. However it never says when to prefer this generic reader over the specific plms_get_* tools, so routing is 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?

Annotations already declare readOnly/openWorld/idempotent/non-destructive, so the safety profile is covered. The description adds beyond that by disclosing the shape of results (sources only, bodies excluded), which is meaningful behavioral context. It omits pagination behavior implied by the limit param.

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 tightly written sentences, with the purpose/scope front-loaded before the follow-up routing hint. Every clause earns its place; 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?

An output schema exists, so return-value description is not required and the "sources" note is a bonus. However, with zero parameter documentation and no explicit sibling routing, the definition is only minimally complete for a search tool with three parameters.

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

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

Schema description coverage is 0% across all three parameters, so the description carries the full burden and fails: it says nothing about what query accepts, how course_id scopes results, or how limit affects pagination. Only the parameter names themselves convey meaning.

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 ("Search") plus the resources it covers (course outlines, assignment lists, notice pages, syllabi), so the agent knows this is a cross-content search rather than a single-resource list/get. It does not explicitly contrast itself with siblings like plms_list_assignments or plms_course_outline, 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?

"Results include sources; fetch notice/attachment bodies separately" is a real routing instruction that tells the agent when to hand off to plms_get_notice/plms_read_attachment. It gives clear context but never states when NOT to use search versus the sibling list tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds a useful security constraint ('without exposing account secrets') but does not describe output format, rate limits, or auth failure behavior. With annotations covering the safety profile, this is adequate but not rich.

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

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

A single front-loaded sentence with no wasted words. It is appropriately sized for a no-param status tool.

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

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

With an output schema, full annotation coverage, and zero parameters, the description provides enough context for an agent to invoke the tool. It could note what capabilities are surfaced, but the output schema covers return values.

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

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

Zero parameters, so the baseline is 4. The schema is empty and fully covered; the description adds no parameter information, but none is needed.

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 ('Check') and resources ('authentication and available read-only capabilities'), clearly identifying a diagnostic status tool. It implicitly distinguishes itself from the data-retrieval siblings, though it does not name them.

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

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

No guidance on when to use this tool versus alternatives; it does not state whether to call it before other tools or under what conditions. The implied use is to verify auth/capabilities, but this is 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?

Annotations already cover readOnly/idempotent/openWorld, so the bar is lower. The description adds genuine context beyond them: the default exclusion of submitted work, and the resilience commitment to "preserve unknown-date items and partial failures" – a non-obvious graceful-degradation trait useful to an agent reasoning about incomplete 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?

Two sentences, no waste, front-loaded with the verb+resource before the behavioral caveats. Every clause earns its place.

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

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

An output schema exists, so return format needn't be described, and failure handling is covered. But with four undocumented parameters at 0% schema coverage, the meaning of days, course_id, and include_overdue is missing – leaving an agent guessing at the primary filtering inputs.

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

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

Schema description coverage is 0%, so the description carries full burden. It only addresses include_submitted (via "excluding confirmed submitted work by default"); days, course_id, and include_overdue have no semantics explained anywhere. Partial compensation, not adequate.

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 ("Aggregate") and resource ("assignment and video deadlines"), which clearly differentiates it from siblings like plms_list_assignments or plms_get_assignment. It stops short of naming an alternative, but the aggregation scope is unambiguous.

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 clause "excluding confirmed submitted work by default" implies the intended use case and hints at the include_submitted parameter's effect. However, it never states when to prefer this tool over plms_export_calendar, plms_list_assignments, or plms_weekly_brief, leaving alternative selection to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds a small amount of structural context (notices are surfaced separately and scoped to affected courses), but says nothing about ordering, limits, or how the aggregation behaves when a course has no deadlines.

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

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

Two short sentences with the core aggregation front-loaded and no filler. The trailing sentence 'Include notices separately for affected courses' is slightly ambiguous in phrasing but does convey output structure.

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?

An output schema exists, so return values need not be explained, and the description does cover the three content blocks. What is missing is how the blocks relate to the undocumented `days` window and what 'affected courses' means, which matters for a multi-source aggregation tool.

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

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

The single `days` parameter has no schema description (0% coverage), so the description must carry it, and 'near-term deadlines' only loosely implies a look-ahead window without naming the parameter or its default of 7. An agent can guess, but the coupling between `days` and the deadline set is never stated.

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 ('Get') and three concrete resources (enrolled courses, near-term deadlines, notices) aggregated into a 'school-life briefing'. This implicitly distinguishes it from single-purpose siblings like plms_upcoming_deadlines or plms_list_courses, though it never names an alternative 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?

Usage is only implied: the word 'briefing' plus 'together' suggests a consolidated periodic summary, and a 7-day default window reinforces a weekly cadence. There is no statement of when to pick this over plms_upcoming_deadlines or plms_list_notices, and no exclusions or prerequisites.

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