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

Beyond the annotations it adds real behavioral detail: the 40MB size limit, cache-reuse behavior for existing copies, and refresh semantics that trigger re-download. This meaningfully enriches an agent's understanding of side effects, though it omits where the file lands and whether overwrites occur.

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 compact sentences, front-loaded with the core action and constraint. Every clause contributes, with no filler or repetition.

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

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

With no output schema and 0% schema coverage, the description should explain return behavior (file path, download handle) and disambiguate id/fileId. It covers security, size, and caching well but leaves the parameter and return contract incomplete.

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

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

Schema description coverage is 0%, so the description must carry the parameters. It explains only 'refresh', leaving 'id' and 'fileId' undocumented apart from the vague notion of 'own material' — a significant gap when the id pattern distinguishes ubfile/resource/folder/file forms.

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 ('본인 강의자료를 ... 로컬에 다운로드합니다') with added scope (up to 40MB, own material). It does not, however, differentiate itself from the sibling 'download_materials', leaving ambiguity about which download 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?

It supplies conditional usage ('refresh=true면 다시 받습니다') and a negative constraint ('임의 URL·경로는 받지 않습니다'), which implicitly tells the agent the tool only takes internal IDs. But it never names an alternative or states when to prefer it over sibling download 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 cover the safety profile (non-readOnly, non-idempotent, non-destructive, openWorld), and the description adds genuinely new behavior: a hard batch cap of 10 and per-item success/failure reporting with a follow-up-call pattern for the remainder. That partial-success semantics is exactly the kind of trait annotations cannot express.

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: the batch operation with its cap comes first, the return semantics second. No filler, no repetition of the tool name.

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

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

With no output schema, the description usefully sketches the return shape (per-item success/failure) and the continuation strategy, which is what an agent needs to loop correctly. It stops short of describing what a failure entry contains or whether succeeded items are re-downloadable, but the core call behavior is covered.

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

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

There is one parameter and schema description coverage is 0%, so the description carries the burden. It conveys that ids are 'selected materials' and repeats the max-10 limit already encoded as maxItems, but never explains the required id prefix format (ubfile/resource/folder/file:hex) or the mixed-type nature of the array.

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 (download material files) plus the batch scope ('한 번에 최대 10개'), which implicitly distinguishes it from the singular download_material sibling. It never names that sibling outright, so the differentiation is inferred rather than explicit.

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 note that leftovers are handled 'via follow-up calls' tells the agent how to deal with items beyond the 10-item cap, which is useful batching guidance. It does not say when to prefer this tool over download_material or download_material's single-file path, so the alternative routing is left implicit.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the bar is lower, and the description adds genuine context beyond them: the RFC 5545 ICS output format and the fact that it is a file snapshot rather than a live subscription. That snapshot-vs-subscription distinction is exactly the kind of behavioral trait an agent needs and would not get from 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?

Two short sentences, front-loaded with the core action and followed by the one caveat that matters. Nothing is wasted and nothing is buried.

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 7-parameter tool with no output schema and zero schema-level parameter descriptions, the description is too thin: it omits scope/filter parameters (courseId, includeTasks, includeSubmitted) and pagination behavior (limit, offset), so an agent cannot call it correctly from the definition alone.

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 7 parameters, so the description carries the full burden of explaining them. It only implicitly references the 'period' (from/to) and says nothing about courseId, includeTasks, includeSubmitted, limit, or offset, leaving most parameters semantically opaque.

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 ('만듭니다' / creates) and resource (a period's schedule as RFC 5545 ICS text), and even names the output format. No sibling is a competing calendar-export tool, so the lack of an explicit sibling contrast is not a real gap, but it also never differentiates from related tools like get_agenda or list_personal_tasks.

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 alternatives named. The one useful signal is the negative constraint ('not an automatic calendar subscription,' i.e. a snapshot), which tells the agent what this is not, but it offers no conditions for choosing this tool over get_agenda or get_schedule_changes.

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=false, openWorldHint=true, destructiveHint=false, idempotentHint=false, so the safety profile is largely covered. The description adds one genuinely useful behavioral fact — output stays local and is never publicly uploaded — which resolves the ambiguity of openWorldHint=true, but it omits where the file is written, overwrite behavior, and whether it requires auth.

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, no filler, with the core action front-loaded and the local-only constraint appended. Nothing in the text is redundant.

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

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

For a mutation tool with no output schema and 0% parameter documentation, the description should at least clarify what 'id' accepts and what fileId adds. It conveys the output artifact but omits where the file lands and how the two identifiers relate, so an agent cannot reliably invoke it.

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 for the two parameters (required 'id' with a compound file:/resource:/folder: regex, optional 'fileId'). The description explains neither the id prefixes nor the id-vs-fileId relationship, leaving the agent to guess how to satisfy the required parameter.

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+target: it extracts material text (with source links and page/slide delimiters) and writes it to a local Markdown file. This clearly separates it from siblings like download_material (binary) and read_material (inline read), 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 by the verb 'save to a local Markdown file'; there is no explicit when-to-use, when-not-to-use, or comparison against download_material / read_material / sync_materials. The closing 'does not publicly upload' hints at a privacy/local-use context but is not framed as guidance.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the bar is lower. The description usefully adds the half-open interval semantics (start inclusive, end exclusive) and the timezone-bearing ISO format. However, it references 'nextOffset' for pagination while the schema exposes offset/limit and no output schema is present, leaving the paging mechanism ambiguous rather than clarified.

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, front-loaded with the scope and interval semantics, with no filler. The pagination sentence is compact, though its nextOffset terminology is imprecise given 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?

For a 7-parameter read tool with no output schema and no parameter descriptions, the definition leaves too much unspecified: filtering behavior (courseId, includeTasks, includeSubmitted), page size, and the exact return/pagination shape. The agent must guess at more than half the 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% across 7 parameters, so the description must carry the load and does not. Only from/to are addressed (as ISO dates with timezone); limit, offset, courseId, includeTasks and includeSubmitted remain entirely undocumented in both places, and the nextOffset mention clashes with the actual offset parameter.

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 resource and scope: school deadlines and personal plans within a half-open interval. An agent can tell it returns aggregated agenda items rather than a single item or raw material. It does not, however, distinguish itself from siblings like list_personal_tasks or get_schedule_changes, which overlap in domain.

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

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

It gives concrete usage conditions for the date format ('ISO dates including timezone') and pagination ('query the next page with nextOffset'), which is real operational guidance. But it never states when to prefer this tool over the many sibling listing tools, nor any exclusion or prerequisite.

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, so safety is covered. The description adds a genuine callability prerequisite not present in structured data: the course must have been synchronized, which implicitly gates the call. It stops short of describing unsynced-course errors or return 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 sentences, zero waste. The scope/sync constraint is front-loaded and the disambiguation follows 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?

For a read-only, single-parameter tool with no output schema, the description conveys both what is retrieved (weekly titles and introductions) and the sync prerequisite. It lacks only edge-case behavior such as error handling for unsynced courses.

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 courseId, its format, or that it refers to a previously synced course. With one undocumented parameter, the description does not compensate for the schema's silence.

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 (reads) and resource (weekly titles and introductions of a synchronized course), and explicitly distinguishes itself from the sibling get_material_outline. An agent can tell the two apart 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?

Explicitly names the alternative (get_material_outline) and the condition that selects it ('for the actual outline of course materials'). The routing decision is fully specified 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is fully covered. The description adds only that the payload includes 'last collection status' alongside courses; it says nothing about freshness, scope, or failure behavior, so it is mildly additive.

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 clause stating verb and resource with zero filler. Nothing could be trimmed without losing meaning.

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 a fully covered schema and no output schema, the description covers the basics but leaves open what 'last collection status' contains and whether the course list is complete or filtered. Slightly thin, though the annotations carry much of the remaining burden.

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 no parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description's mention of 'regular courses' hints at the scope of the result set but adds no parameter-level detail because none exists.

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 ('읽습니다' / reads) and the resources it returns: regular courses (정규 강좌) plus last-collection status. An agent can tell what the tool fetches. However, it does nothing to distinguish itself from siblings like get_course_outline or get_source_status, so it stops at 4.

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 indication of when this tool should be chosen over alternatives such as get_course_outline, get_source_status, or the material-listing tools, nor any stated prerequisites. The agent must infer usage 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, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description's 'does not submit/take' statement largely restates that, though it does add the useful return-content hint (원문 링크) that annotations cannot convey.

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

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

Two short sentences with no filler; the positive capability (details + source link) is front-loaded and the negative constraint follows 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?

For a single-parameter read tool with no output schema, the description covers what is returned and confirms no side effects, which is about the right amount of context. It leaves the id format and the relationship to the search/list siblings 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?

There is one parameter with 0% schema description coverage, so the description must carry weight; it does clarify that the item is either an assignment or a quiz, which matches the 'assign|quiz' id pattern. It still never explains the required id format or where an id comes from, so the compensation is only partial.

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 resource (과제/퀴즈, i.e. assignment/quiz) and what it returns (details plus the original source link), so an agent knows this is a detail-fetch, not a list or search. It does not, however, explicitly differentiate itself from siblings like search_items or list_materials.

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 '실제 제출/응시는 수행하지 않습니다' implies this is for inspection only and rules out submission/exam-taking intent, which is useful boundary-setting. But it gives no positive when-to-use guidance and never routes the agent to search_items or other siblings for discovery.

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 openWorldHint=true, idempotentHint=false and readOnlyHint=false, so the agent knows this is a state-affecting, network-touching call. The description usefully adds that refresh=true re-verifies links against the school source, which explains the non-read-only/idempotent profile, but says nothing about latency, auth requirements, or what changes on refresh.

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 with the core action front-loaded and no filler. Slightly terse for the amount of unexplained behavior, but appropriately sized.

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 should describe what the returned attachment list contains (fileIds? names? download keys), especially since it tells the agent to 'choose a fileId'. It also leaves the mismatch between '조회' and readOnlyHint=false unaddressed. Adequate but with clear gaps for a tool the agent must chain from.

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

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

Schema description coverage is 0%, so the description must carry the load. It documents refresh well ('refresh=true re-checks links from the school source') but never explains the required id parameter or the ubfile/resource/folder/file prefix forms allowed by the schema pattern. Half the parameters remain opaque.

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 and resource: it retrieves the actual attached-file list for one material, which distinguishes it from the sibling list-style tools (list_materials, search_materials). It does not explicitly name a sibling alternative, so it falls short of a 5.

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

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

It gives downstream guidance ('if multiple files, choose fileId') and explains the refresh flag's purpose, implying when to use it, but never states when to prefer this over get_item, list_materials, or read_material. Usage is inferred rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description contributes beyond them by specifying scope ('현재 계정의 로컬' cache) and enumerating the exact values returned, which matters because there is no output schema – though it stops short of units for the capacity figure.

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, no restatement of the tool name, and the returned metrics listed compactly. Nothing could be removed 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?

Zero parameters, full annotation coverage, and no output schema – the description compensates by naming the three values it reports, which is exactly what is needed. The only gap is that it does not specify the unit/format of the capacity value or how the result is presented.

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 of 4 applies; there is nothing for the description to disambiguate, and it correctly avoids describing non-existent inputs.

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 (확인합니다 – check/report) and a precise resource (the current account's local material cache), plus the three metrics returned (capacity, file count, index count). It is clearly distinct from siblings like list_materials, search_materials, or index_materials, though it never names an alternative to distinguish itself explicitly.

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

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

The purpose implies a diagnostic/status-check use case, so an agent can infer when to reach for it, but there is no explicit when-to-use statement, no guidance versus get_source_status or index_materials, and no stated prerequisites (e.g., whether a login or prior sync is required).

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=false, destructiveHint=false, openWorldHint=true and idempotentHint=false. The description adds real behavioral context beyond them: it discloses that output is counts plus per-section first sentences and that '읽기 제한' (reading restrictions) may apply, which signals partial content access. It does not, however, explain why a 'get' preview is annotated as non-read-only/non-idempotent, leaving a mild tension unaddressed.

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

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

Two short sentences, front-loaded with what is returned and followed by the distinguishing 'not a summary' qualifier. No filler, though the second sentence could be merged or trimmed.

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

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

There is no output schema, so the description must cover returns; it does say what is returned (page/slide counts, first sentence per section, read restrictions) but not the response shape, ordering, or how the paging parameters affect results. Adequate but with clear gaps for a four-parameter tool with zero schema documentation.

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

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

Schema description coverage is 0% across four parameters, so the description carries the burden. It mentions '각 구간' (each section), which loosely hints at the limit/offset paging model, but it never explains limit, offset, fileId, or the prefixed id pattern, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('자료의 페이지·슬라이드 수, 각 구간의 첫 문장과 읽기 제한을 확인합니다') and clarifies the nature of the output as raw preview rather than an auto-generated summary. It is distinguishable from sibling read/summary tools, though it never names a sibling to sharpen 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?

The phrase '자동 생성된 요약이 아닌 원문 미리보기입니다' implies when to choose this over a summary route, which is useful implied guidance. However, no explicit when-to-use condition, prerequisite, or named alternative tool (e.g., get_material, read_material) is 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 declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds genuinely new behavioral context — a 90-day retention window and cursor-based pagination — but says nothing about what happens outside that window, ordering, or rate limits.

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

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

Two short sentences with zero filler; the scope (90 days, change types) is front-loaded and the pagination instruction follows. 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?

With no output schema, the description should ideally state that results are paginated with a nextCursor — it only implies this. The `limit` parameter and the return structure remain unexplained, leaving the agent to infer the pagination contract from one hint.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It does explain `after` as the previous nextCursor, which the bare integer schema does not, but `limit` is left completely unaddressed. 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?

The description names the resource and its content precisely: additions, due-date/status changes, and missed records over the last 90 days. An agent can tell it returns a change log, not a schedule view. However, it never distinguishes itself from siblings like get_agenda or list_personal_tasks, which also surface schedule data.

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

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

The second sentence implicitly defines the usage pattern: pass the previous nextCursor in `after` to page through results. That is useful procedural context, but there is no explicit when-to-use-this-vs-alternatives guidance and no mention of prerequisites or when the 90-day window makes it inapplicable.

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 read-only/idempotent/open-world, but the description adds real behavioral detail beyond them: only verify=true causes server contact and session validation, and the credential-handling constraint ('do not pass passwords or cookies as arguments') is an explicit safety rule not expressed anywhere in the 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?

Three short sentences, front-loaded with what the tool is, then the verify behavior, then the credential prohibition. No filler; each sentence carries distinct 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?

No output schema exists, and the description gestures at return content (connection status and supported format) but never states what a status response looks like, nor whether authentication must already exist for verify=true to succeed. Coverage is adequate but leaves an operational gap for a network-facing 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 single parameter — and it does, explaining that verify=true is the only mode that reaches the server and validates the session, implying the false default is a passive status read. It stops short of describing return shape but the flag semantics are 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?

Names the resource (school direct connection status and supported formats) and the distinguishing trait ('Chrome을 사용하지 않는' – the non-browser direct path), which separates it from the browser-based login flow implied by the sibling start_school_login. There is no explicit verb, but the intent is recoverable.

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 reader infers this checks connection status rather than performing a login, and that verify=true triggers actual server contact. The sibling start_school_login is never named as an alternative, so the agent must guess the boundary between 'check connection' and 'start login'.

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

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

The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds value beyond them by enumerating the categories of information the status report contains (last collection time, stale data, missing items, supported scope), which is meaningful because there is no output schema to describe the return.

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 listing the four things checked, with no filler or redundancy. Appropriate size for a zero-parameter read tool.

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

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

For a parameterless read tool with no output schema, the description compensates by naming the reported fields, so an agent knows what it will get back. It stops short of explaining how to act on 'stale' or 'missing' findings, but the essentials for invoking the tool 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?

The tool takes zero parameters, so the schema has nothing to document and the baseline is 4. Nothing in the description conflicts 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?

The description names a specific resource (수집/source status) and enumerates exactly what is inspected: last collection time, stale data, missing items, and supported scope. The verb '확인합니다' (check) is a bit generic, and no sibling tool is named for contrast, but the resource is distinct enough that an agent can tell this apart from get_material_cache or get_school_connection.

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 prerequisites, and no named alternative. A capable agent can infer this is a diagnostic/status check, but nothing in the description states when to reach for this tool versus its many siblings.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true and idempotentHint=false, so the agent knows this writes and is not idempotent. The description adds the real side effect (text index creation) and the batch ceiling, but says nothing about re-indexing an already-indexed file, processing time, or whether the job is synchronous. With annotations carrying 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?

Three short sentences, action first, then the batch constraint, then the follow-up step. No filler and nothing buried.

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 batch tool with no output schema, the essentials (what it does, batch cap, next step) are covered, but the agent still doesn't know what a call returns, whether indexing is asynchronous, or how failures on individual IDs are surfaced.

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 'ids' parameter has 0% schema description coverage, and the description only echoes the batch size (max 10) already enforced by maxItems. It never explains the accepted ID forms (ubfile:/resource:/folder:/file: hex), which the pattern encodes but the agent gets no prose explanation for.

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

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

States a specific compound action: download the selected materials AND build a text index, which distinguishes it from pure-download siblings like download_material/download_materials. It does not explicitly say how it differs from those siblings, so the agent must infer that indexing is the added value.

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 workflow condition: after completion, use search_materials to search. It also constrains the batch to 10 files per call. However, it never states when to prefer this over download_materials or download_material, so alternatives are not addressed.

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, so the safety profile is covered. The description adds non-obvious behavior beyond that: results are limited to previously synced materials, the agent should inspect source.stale for freshness, and an empty result is a signal to re-sync — a genuinely useful recovery path.

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 with no padding, front-loading the resource and its filter facets before the operational hints. The only weakness is that 'source.stale 확인' is compressed to the point of ambiguity.

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 6-parameter list tool with no output schema and zero schema descriptions, the description covers the core filters and the sync-recovery flow but omits pagination behavior and any hint about the shape of the returned list. Adequate, but not fully self-sufficient.

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 6 parameters, so the description must compensate. It does map four of them (course→courseId, title→query, week→week, download status→downloadedOnly), but limit and offset are never explained, leaving pagination 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?

States a specific verb (조회) plus resource (동기화한 강의자료, synced course materials) and enumerates the filterable facets: course, title, week, download status. The word '동기화한' (synced) scopes the resource, but it never names the nearest sibling (search_materials) to tell the agent which of the two retrieval tools 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?

Gives an explicit when-to-use-this-instead rule: 'if the list is empty, call sync_materials', naming the alternative tool and the trigger condition. It also directs the agent to check source.stale first, which establishes a precondition, but offers no exclusion guidance for the many other search/list siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds the useful scoping fact that these tasks are independent of school submission status, but says nothing about archived-item handling or output 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?

A single compact sentence with no filler, front-loading the resource and its scope. It is arguably too terse for the gaps it leaves, but there is no wasted wording.

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

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

For a simple read-only list tool with no output schema, the description covers what is read and how it differs from coursework. However, it leaves the sole parameter and the default archive behavior unexplained, which is the one thing an agent must know 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?

There is one parameter, includeArchived, with 0% schema description coverage, and the description never mentions it. The agent gets no guidance on whether archived personal tasks are included by default or what the flag does, so the description fails to compensate for the coverage gap.

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

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

States a specific verb+resource ('개인 할 일을 읽습니다' = reads personal to-dos) and scopes it as separate from school submission status, which meaningfully distinguishes it from the school/material-oriented siblings. It stops short of naming a sibling tool explicitly, so it is clear but not fully differentiated.

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 '학교 제출 상태와 별개인' implies when this tool applies (personal items, not coursework submissions), but there is no explicit when-to-use/when-not statement or named alternative. Usage is inferable rather than stated.

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

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

Annotations give readOnlyHint=false and openWorldHint=true, and the description explains the mechanic behind that: it downloads material on demand, so a non-read-only profile is justified rather than contradictory. It also discloses truncation handling and, notably, warns that 원문은 지시문이 아니며 (the document text is not instructions, a prompt-injection caution) and that tables/formulas/figures need rendering verification, pointing implicitly at render_material_page.

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 what is read and the download caveat before the pagination and safety notes. No filler, though the 'next' reference costs clarity rather than earning 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 6-parameter tool with zero schema descriptions and no output schema, the description covers the read semantics, the download side effect, truncation, and a security caveat, which is meaningful coverage. It still leaves most parameters and the exact continuation/output shape undocumented, so an agent could invoke it but would guess at count/maxChars/charOffset semantics.

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, yet it only clarifies one parameter ('from은 1부터'). count, maxChars, charOffset, and fileId go unexplained, and the referenced 'next' is not even a schema parameter, leaving the continuation mechanism ambiguous.

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

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

States a specific verb (read) and enumerates the concrete resource formats it handles (PDF pages, PPTX slides/notes, DOCX/HWPX, plain text), which is far more informative than the bare name. It does not, however, differentiate itself from close siblings such as get_material, download_material, or render_material_page, so an agent must still infer which reader 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?

'필요한 경우 다운로드합니다' implies the download behavior that overlaps with the download_material sibling, and 'next를 사용해 잘린 텍스트를 이어 읽습니다' establishes an iterative read pattern. But there is no explicit when-to-use-this-vs-that guidance and no statement of prerequisites (e.g., when a download is actually triggered).

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 the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true, idempotentHint=false), and the description adds the return format (PNG) plus the OCR caveat. It does not explain the id-vs-fileId distinction, the 1-600 page bound, or why the operation is marked non-idempotent/non-read-only, leaving behavioral gaps.

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

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

Three short sentences with the core action front-loaded, and the final 'not automatic OCR' line earns its place by preventing a common misuse. 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 3-parameter tool with no output schema, the description covers the return format and usage intent, but with 0% schema coverage and no output schema it should at least distinguish id from fileId. Adequate but with a clear gap around parameter meaning.

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, and it says nothing about the required id parameter, the optional fileId, or how page numbering works. Merely implying 'one page of a PDF' does not clarify the two identifier schemes at all.

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 ('render one PDF page as a PNG image and return it') and pins the scope to a single page, which cleanly separates it from sibling text-extraction tools like read_material or download_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?

It gives positive usage context (checking formulas, tables, figures, scanned pages) and an explicit exclusion ('not automatic OCR'), so an agent knows when this beats text-reading siblings. It stops short of naming the alternative tool to use instead for OCR/text needs.

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 covered. The description adds one genuinely useful behavioral fact not in structured data: results are capped at 100. It says nothing about ordering, pagination behavior, or whether the cap means results are truncated.

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, front-loaded sentences with no filler. It is economical, but the brevity here reflects under-specification rather than tight editorial trimming.

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, 0% parameter coverage, and three unannotated parameters, an agent still cannot tell how to paginate or scope by course. For a search tool in a crowded sibling set, the description leaves too much to guessing.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It partially explains 'query' (title search) but never mentions 'offset' pagination or the 'courseId' scoping filter, leaving two of three parameters unexplained 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 (search) and the field searched (title), and adds the scoping nuance that items without a due date are included. However, it never distinguishes itself from the sibling search_materials or get_item, so 'items' remains ambiguous in a toolset full of item/material search tools.

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

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

There is no guidance on when to use this versus search_materials, get_item, or list_personal_tasks. The 'including items without a due date' clause hints at a use case but is never framed as a selection condition.

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 closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: it operates only over already-read or indexed material, returns page/slide-level evidence with excerpts, and results can be incomplete because uncovered files are flagged. Return granularity and coverage behavior are real 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?

Two sentences, no filler: the capability and its return value come first, the coverage caveat second. Both sentences carry information 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?

With no output schema, four undocumented parameters at 0% coverage, and no explanation of pagination or course scoping, the definition is not complete enough to call this tool confidently. The coverage caveat helps, but the parameter and result-shape gaps remain.

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 four parameters (query, limit, offset, courseId), so the description carries the full burden — and it mentions none of them. It never explains that courseId narrows the search to a course or that limit/offset control pagination, leaving the agent to infer all parameter meaning from names and constraints alone.

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

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

The description gives a specific verb and resource: it searches the body text of materials that have already been read or indexed, and it states what is returned (evidence pages/slides plus excerpts). It implicitly distinguishes itself from get_material/list_materials by scoping to content search, though it never names a sibling it is not.

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 (search material contents to find supporting passages), and the coverage disclaimer ('files missing from coverage are indicated; do not treat this as searching all school materials') is a useful boundary. There is no explicit when-to-use-vs-alternative guidance, e.g. search_materials versus search_items or read_material.

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 annotations, it discloses that the URL is scoped to this PC, that it expires after 15 minutes, that no credentials are accepted as input, and how completion is detected. This is exactly the behavioral context annotations cannot express, and it is consistent with readOnlyHint=false (a creation action).

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

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

Four short sentences, each carrying a distinct fact (purpose, how-to, constraint, lifecycle/completion), with the action front-loaded ahead of the caveats. No wasted words.

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

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

For a zero-parameter, no-output-schema action tool, the description covers the full interaction lifecycle: trigger, user-facing step, credential safety, expiry, and how to confirm completion. Nothing an agent needs to invoke and drive it correctly 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?

The tool takes zero parameters, so the 4 baseline applies. The description reinforces this by explicitly stating it does not accept password or cookie arguments, which reassures the agent no hidden input 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?

States a specific verb and resource: it creates a PC-specific login-screen URL in response to a user's school-connection request. It also names the companion tool get_school_connection, giving the agent a clear boundary, though it does not explicitly contrast itself with every sibling.

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

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

Explicits the trigger (user requests a school connection), the required follow-through (open the URL in a browser and have the user type their own credentials), a negative constraint (no password/cookie arguments), and the completion step via get_school_connection. Alternatives and conditions are all stated, nothing 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?

With annotations already declaring readOnlyHint=false, openWorldHint=true, and non-destructive behavior, the description adds real context beyond them: it clarifies the fetch is fresh (not cache-served), caps the default scope at 10 courses, and explicitly states files are not downloaded, which routes the agent away from download_material.

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 tight sentences with no filler; the core action is front-loaded and the two most decision-relevant constraints (scope cap, no file download) follow 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?

With no output schema, the description does describe what is produced (material list plus week structure) and covers the key scope and no-download caveats, so it is largely sufficient for a one-parameter tool. Gaps remain around what local state the sync updates (consistent with readOnlyHint=false) and any error/rate 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 0% for the single courseId parameter, so the schema itself carries no semantics. The description partially compensates by explaining the omission behavior (up to 10 courses), but it does not clarify the accepted format (the positive-integer string pattern) or the effect of supplying a value.

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-and-resource pair: it freshly re-fetches ('직접 새로 조회') the course-material list and week structure from the user's current enrollments. This 'fresh fetch' framing implicitly distinguishes it from cache reads like get_material_cache, but it never names a 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?

Usage is implied rather than stated: '직접 새로 조회' suggests using this when fresh data is needed versus cached data, and the courseId-omission cap is given, but there is no explicit when/when-not guidance or named alternative among the many material siblings.

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