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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description goes beyond this by disclosing the key behavioral trait: the MCP makes no LLM API call and is a pure assembly operation. Knowing this tool has zero external side effects and does not itself perform the summary is genuinely valuable context that the annotations do not fully convey. No contradiction with the annotations; the description reinforces them.

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

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

The purpose is front-loaded in the first sentence, followed by a valuable clarifier about not calling the LLM, then clean Args/Returns sections. The structure is tidy and scannable. The Args section slightly duplicates the schema parameter documentation, but the '요약은 호스트가 한다' sentence earns its place as it materially shapes how an agent should invoke the tool. No unnecessary bulk.

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

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

For a single-optional-parameter tool with an output schema present and 100% schema coverage, the description is quite complete: it covers purpose, the non-calling-LLM behavior, the parameter, and gives an overview of the return (rules + required sections + document list + raw text in the prompt field). Since an output schema exists, the description need not detail the return structure further. Minor omission: it does not state prerequisites like the target folder needing to be scanned first, but the sibling scan_folder_structure makes this 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 coverage is 100%: the schema description for with_line_numbers already explains line-number attachment and the 'L14' citation rule, which is actually richer than the description's own '원문 줄 번호 부착 및 인용 규칙 추가 여부'. Both sources note the default of true. Per calibration, high schema coverage yields a baseline of 3, and the description adds only marginal value beyond what the schema provides.

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

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

The description states a specific verb and resource: it returns a summary prompt that combines all target-folder documents with a standard report format. It also clarifies what the tool is not — it does not call an LLM and does not summarize itself, which sharply distinguishes it from every sibling (scan_folder_structure, extract_key_terms, validate_report_draft, etc.). An agent can tell this is the assembly step versus the read/extract/validate steps 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?

The description clearly explains the tool's role in the workflow — it assembles instructions plus raw text for the host to consume, and explicitly states the LLM API is NOT called so the host does the summarizing. This tells the agent when to invoke it (as the prompt-building step before summarization) and why. It does not name specific sibling alternatives with when-not conditions, but the role is distinct enough among the siblings that this is a minor gap.

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

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

Beyond the readOnly/idempotent/non-destructive annotations, the description discloses the tool is heuristic, may produce false positives, is advisory, and returns a GroundingResponse with status/score/findings. This adds crucial context about reliability and non-blocking behavior, which annotations alone do not convey.

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

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

Front-loads the core purpose, then explains advisory nature, then lists args/returns. The Korean text is somewhat verbose but each section serves a function and the structure is clear and logical.

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 tool with an output schema, the description covers the core function, advisory behavior, and return structure. It does not explicitly mention dependency on a prior folder scan, but that is inferable from sibling tools and the described purpose. Sufficient for correct invocation.

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

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

Schema description coverage is 100% and the description merely repeats the parameter meaning (full draft markdown). It adds no extra semantic beyond what the schema already states, so the baseline of 3 applies.

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

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

Description states a specific verb+resource: it checks file names mentioned in a report against the current folder scan results. It distinguishes itself from validate_report_draft by noting that the save gate is that tool plus user approval, so the agent can tell them apart.

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 states the tool is advisory, heuristic, may have false positives, and does not block saving, contrasting with validate_report_draft as the structural gate. However, it does not explicitly say when to call it (e.g., after scan_folder_structure) or provide alternatives beyond the save-gate distinction.

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, covering the safety profile. The description adds value beyond this by disclosing the overwrite semantics of a second save (currently a write operation yet non-destructive to this call) and the diff.write_mode return range (CREATE/OVERWRITE/NO_CHANGE). With annotations covering safety, this is solid supplementary context with no contradiction.

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

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

The description is efficiently front-loaded with the purpose, followed by the overwrite warning and a compact Args/Returns block. The structure is clean and scannable, though the Args section is somewhat redundant with the schema. Minor waste, but nothing excessive.

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

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

Given a full input schema, an output schema describing DiffResponse, and annotations covering the safety profile, the description covers the purpose, the when-to-use scenario, and the key behavioral caveat (overwrite risk). Nothing critical an agent needs to call it correctly is missing; it could name alternatives, but overall it is 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 coverage is 100% — all three parameters (report_id, report_markdown, diff_preview_lines) are described in the schema, including the default of 40 for diff_preview_lines. The description's Args section largely restates this, adding negligible meaning beyond the schema. Baseline 3 is appropriate given the schema carries the load.

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+resource: it shows the diff between an already-saved report and a draft ('이미 저장된 보고서와 초안의 차이를 보여 줍니다'). This clearly distinguishes it from save/validate siblings (save_approved_report, validate_report_draft) by its comparative, non-writing role. It stops short of naming a sibling explicitly, but the purpose 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 description gives clear when-to-use context: a second save with the same report_id overwrites the existing file, so this tool exists to check what will be lost before that happens ('무엇이 사라지는지 먼저 확인해 사고를 막는 용도'). This strongly implies use before overwriting, though it does not explicitly name alternatives or exclusion conditions.

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, openWorldHint=false, covering the safety profile. The description adds useful behavioral detail beyond annotations — the three heuristic rules and that results include original line numbers as evidence. This adds value without contradicting 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?

Purpose is front-loaded in the first line with the three heuristics following compactly. The Args/Returns block partly duplicates the schema and output summary, but the line-number-evidence detail is genuinely additive. Reasonably sized with minimal waste.

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 an output schema (OutlineResponse with level, title, line), the description covers the essential behavior and return semantics. It explains what heuristics produce candidates and that line numbers serve as evidence. Nothing critical is missing for correct invocation, though it could briefly note what disqualifies a line from being an outline candidate.

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

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

Schema description coverage is 100%, with relative_path already described as '문서 상대 경로' in the schema. The description repeats the same parameter explanation verbatim, adding no new meaning about format, constraints, or interpretation beyond the schema. At full coverage, the baseline 3 is appropriate.

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

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

States a specific verb (extract), resource (document outline), and the three heuristic strategies (markdown headings, numbered items, all-caps lines). The intent is unambiguous and distinguishable from siblings like extract_key_terms or scan_folder_structure. Slight deduction for not explicitly positioning itself against those siblings.

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 usage for unstructured documents with inconsistent formatting ('비정형 문서는 형식이 제각각이므로'), which gives context on when it applies. However, it never states when not to use it or names alternative tools (e.g., scan_folder_structure for structural scans). Usage context is present but no exclusions.

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 clear. The description adds valuable behavioral context: the extraction is deterministic (same document always yields same results) and uses regex and frequency rather than statistical NLP. This goes beyond the annotations by describing the method and consistency guarantees, which helps the agent trust the tool for reproducible use.

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

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

The description is structured with a clear opening line stating the tool's function, followed by Args and Returns sections. It is not overly verbose; about 100 words in Korean. Key facts (determinism, regex usage) are front-loaded, and the parameter descriptions are wrapped into sections. A slight deduction for the Returns section being somewhat redundant with the output schema, but overall well-organized and efficient.

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 has a simple signature (2 parameters, 1 required) and an output schema that covers return structure, so the description does not need to detail return types extensively. It provides enough context for correct invocation: it names the parameters, explains the deterministic behavior, and notes the output categories (dates, numbers, frequent_terms). It lacks explicit usage guidance and error conditions, but these are minor gaps given the simplicity and existing annotations. Overall, it is sufficiently complete for an agent to call the tool 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 coverage is 100% for both parameters, so the baseline is 3. The description adds meaning beyond the schema: it clarifies that max_terms is 'per category' and notes it is 'for context protection' (컨텍스트 보호용), which explains the purpose of the limit. It also frames relative_path as a 'document relative path,' matching the schema but reinforcing usage. This extra insight justifies a score above baseline.

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

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

The description clearly states the tool extracts dates, numbers with units, and frequency-based key term candidates from documents. It uses specific verbs ('extract') and resource types, and is distinct from siblings like extract_document_outline (which handles outlines) and read_document_chunk (which reads content). The purpose is immediately understandable without ambiguity.

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 usage for pulling key terms and metadata from a document, but it does not explicitly mention when to use this tool versus alternatives such as extract_document_outline or build_summary_prompt. No exclusions or alternative routing are provided, so an agent would need to infer context from sibling names rather than direct 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 convey read-only and non-destructive nature. The description adds the overwrite warning and details the returned fields (report_id, path, line count, UTC timestamp, content hash prefix), enriching behavioral context beyond 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 punchy sentences plus a return specification. Purpose is front-loaded, every sentence earns its place, and there is no fluff.

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-only tool with an output schema, the description covers purpose, return contents, and usage timing. Nothing an agent needs to invoke 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?

Tool has zero parameters; baseline is 4. No parameter explanation needed, and schema coverage is irrelevant with 0 params.

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

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

The description clearly states it lists saved summary reports ('이미 저장된 요약 보고서 목록을 조회합니다') and explains its role in checking before saving. This distinguishes it from write operations like save_approved_report.

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

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

It explicitly says when to use: before saving, to avoid overwriting (같은 report_id로 저장하면 덮어쓰기가 되므로, 저장 전에 확인). It does not name alternatives, but the context is clear among 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 carry the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true), so the description's burden is light. It adds useful behavioral context beyond annotations: the tool applies extension/size filtering and guarantees the returned documents are readable and summarizable, plus it discloses the exact fields in each entry. There is no contradiction with the annotations.

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

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

Three short paragraphs in Korean, each earning its place: purpose/filter criteria first, the cross-tool relative_path guidance second, and the return-format disclosure third. Front-loaded and no filler. It could arguably merge the return-format paragraph with the first, but the structure is clear and efficient.

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

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

For a zero-parameter, read-only list tool with an output schema, the description is largely complete: it explains filtering behavior, identifies the key deliverable (relative_path), and the output schema covers the return structure. The only minor gap is the absence of an explicit mention of the global list of documents the tool filters over, and no downside/edge-case disclosure (e.g., what happens when no documents pass the filters).

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

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

The tool has zero parameters, so the schema carries no semantic burden that the description must compensate for. Per the rubric, this earns the baseline of 4. The description appropriately focuses on output semantics (returned fields: relative_path, size, line count, modification time) rather than parameter syntax, which is irrelevant here.

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+resource: it returns the list of documents that passed extension/size restrictions and can actually be read and summarized. This clearly distinguishes it from siblings like scan_folder_structure (raw folder tree, not filtered documents) and list_saved_reports (previously saved reports, not analysis targets). Scope and filtering criteria are 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 description gives actionable usage guidance by telling the agent that the relative_path obtained here is passed as-is to all other tools, establishing this as the canonical entry point for document selection. However, it does not explicitly state when to prefer siblings like scan_folder_structure or list_saved_reports instead — the exclusion logic is left to inference 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 already indicate readOnlyHint, idempotentHint, and destructiveHint false. The description adds crucial context: approval_token is issued only after structural validation, the token is a hash of (report_id, body) ensuring content integrity, and it does not replace user approval. This goes beyond the annotations to explain the tool's internal logic and constraints.

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

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

The description is well structured, leading with the core purpose, then workflow details, a security warning, and parameter documentation. It is somewhat long but each section serves a purpose. It could be tightened by omitting the redundant parameter descriptions, but overall it is organized and front-loaded.

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

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

Given the tool has an output schema (PreviewResponse) and is part of a multi-step workflow, the description fully covers the operational flow: when the token is generated, how to use the response, and the explicit order of operations. The agent has enough information to invoke it correctly and know what to expect without any 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 coverage is 100%, so the schema already documents each parameter thoroughly. The description's Args section essentially repeats the schema text without adding new meaning. It does not reveal, for example, the impact of include_preview on token generation or how max_preview_chars interacts with validation. It meets the baseline but adds no extra insight.

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

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

The description clearly states it shows the save target, changes, and validation results, and issues an approval token. It explicitly positions itself as the 'single gateway before saving' and distinguishes from save_approved_report, which is the actual save operation. The purpose is specific and actionable.

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 explains it must be used before saving, and explicitly instructs that save_approved_report should be called only after showing the approval_request to the user and receiving explicit approval. This provides clear when-to-use guidance and references the sibling tool directly.

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 (readOnlyHint=true, idempotentHint=true), the description discloses error behavior: it raises ToolFailure with DOCUMENT_NOT_FOUND/INVALID_PATH and includes a list of available paths in the error message. It also explains the return fields (content, total_lines, truncated). This additional context helps the agent anticipate failures and interpret responses, exceeding what annotations alone provide.

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

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

The description is well-structured with clear sections (Args, Returns, Raises) and is appropriately sized. The core purpose is front-loaded in the first sentence, and the rest is organized logically. However, the Args section redundantly lists parameters that are already fully described in the schema, which is a minor inefficiency but not bloated.

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

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

Given that an output schema exists (DocumentChunkResponse), the description still adds value by explaining error scenarios and the meaning of the response fields. It covers the essential context for correct invocation—path specification, line range semantics, and error handling. While pagination or performance limits are not mentioned, they are not necessary for a read tool with these annotations and output schema.

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

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

Schema description coverage is 100%, so each parameter already has a detailed description, including examples and defaults (e.g., with_line_numbers for citation anchors). The description's Args section largely paraphrases these schema definitions without adding new semantic information. Thus, it meets the baseline but does not enrich parameter understanding beyond the schema.

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

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

The description opens with a clear statement of the verb and resource: "relative_path에 해당하는 문서 원문을 읽습니다" (reads the original document at relative_path). It further specifies chunked reading via line ranges, which distinguishes it from siblings like extract_document_outline (structural extraction) and list_target_documents (listing). The purpose is immediately understandable.

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 provides a usage tip: "긴 문서를 통째로 읽어 컨텍스트를 낭비하지 않도록 줄 범위를 지정할 수 있습니다" (specify line ranges to avoid wasting context on long documents). This implies when to use line ranges, but it does not explicitly state when to prefer this tool over alternatives, nor does it mention exclusions or fallbacks. No sibling comparison is offered.

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 state readOnlyHint, idempotentHint, and destructiveHint. The description adds the return shape (AuditResponse with events[] in latest order) and confirms the read-only nature. It provides useful behavioral context beyond the annotations without contradicting them.

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

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

The description is concise with a clear structure: a first line explaining what the tool does, a usage note, then Args and Returns. It is front-loaded and avoids verbosity, though it repeats some parameter details already present in the schema, which is slightly redundant but acceptable.

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

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

Given the presence of an output schema and the tool's simplicity, the description is complete. It explains the purpose, usage context, ordering, and return format. No additional information is needed for an agent to correctly invoke the tool, as all parameters are optional and clearly described.

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 descriptions cover both parameters fully, including defaults and constraints. The description repeats the parameter list and adds minor clarifications (e.g., '선택' for optional, '생략하면 전체' for report_id). This is consistent with the baseline of 3 when schema already does the heavy lifting.

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

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

The description clearly states the action (조회 - retrieve) and resource (보고서 저장 감사 로그 - report save audit log) and specifies the ordering (최신순 - latest). It also includes a concrete usage scenario (AWAITING_APPROVAL → SAVED flow), which effectively differentiates it from sibling tools like list_saved_reports or save_approved_report.

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

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

The description gives an explicit trigger for when to use: when verifying execution evidence of the AWAITING_APPROVAL → SAVED flow. However, it does not mention when not to use or suggest alternative tools, so it lacks explicit exclusions. Thus a 4 is appropriate.

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 carry readOnlyHint=false, destructiveHint=true, and idempotentHint=true, so the bar for extra disclosure is lower — yet the description still adds critical context: the token guarantees only technical integrity (approved content == saved content), NOT user approval, which is a crucial safety clarification. It also discloses the OVERWRITE destructive mode and the WRITE_MODE_CHANGED rejection mechanism, deepening understanding of the idempotent+destructive combination.

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?

Well-structured with clear section headers (Args, Returns, Raises), a front-loaded purpose statement, and numbered preconditions that make the safety gate easy to parse. Slightly verbose — the Args block largely duplicates schema descriptions and the Raises list could be trimmed — but every section earns its place in an approval-gated tool where safety detail matters.

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 tool with a conditional approval workflow, the description is complete: it covers the preconditions, the token semantics and its limitation, the error types with recovery info, the output shape (SaveResponse with path/audit/write_mode), and the optional expected_write_mode safeguard. Output schema exists and parameter coverage is 100%, so nothing an agent needs to call this 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?

Schema coverage is 100% and the schema itself already documents all four parameters well, including the critical constraint on report_markdown ('even one character different fails token verification') and expected_write_mode's overwrite-protection purpose. The description's Args section restates these rather than adding materially new meaning, though it does reinforce the cross-parameter binding (token must originate from preview, markdown must match preview) in the flow context.

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 opens with a specific verb+resource+condition: 'saves the report to file only when the approval token issued in preview matches.' This clearly differentiates it from sibling tools — it explicitly declares itself 'the only write tool on this server,' which is a concrete distinguishing claim against the read/validation siblings like preview_save_report and list_saved_reports.

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 two explicit numbered preconditions that must hold before invocation: (1) preview_save_report returned AWAITING_APPROVAL and issued a token, and (2) the user has explicitly approved saving. It goes further with a clear exclusion: 'Do not call unless the user said save.' This gives the agent unambiguous go/no-go criteria.

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?

Despite annotations already declaring readOnlyHint, idempotentHint, and destructiveHint, the description adds valuable context beyond them: it explains the recursive scan nature, the semantics of `allowed` and `reason` (why files are inaccessible due to extension/size limits), and the response structure including `truncated` for item count limits. This enriches the agent's understanding of tool behavior without contradicting any annotation.

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

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

The description is well-structured with clear paragraphs: main action, then allowed/reason explanation, then Returns block, then Examples. It is somewhat lengthy (about 10 lines) but every sentence adds value, including the heuristic about `allowed` and the example usage. It front-loads the core purpose and doesn't waste words, though it could be slightly tighter by merging some explanatory sentences.

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

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

Given the tool has no parameters, a rich output schema (as indicated by 'Has output schema: true'), and the description already covers the return fields, the tool is completely specified. It explains the `allowed`/`reason` semantics that are crucial for agent decision-making, mentions the `truncated` field, and provides usage examples. No critical information is missing for an agent to correctly invoke this 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 tool has zero parameters, so the baseline is 4 per instructions. The description doesn't need to elaborate on parameters, and it correctly focuses on output semantics. Since schema coverage is 100% (vacuously true with no props), no additional parameter documentation is required. The description effectively explains the return structure, which is the relevant semantic content.

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

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

The description clearly states the tool recursively scans a fixed target folder and returns the file structure. It uses a specific verb ('훑어' - scans) and resource ('대상 폴더'), and distinguishes itself from siblings by explicitly mentioning it is the 'starting point of folder analysis' and giving a concrete example of when not to use it (when you already know the target file and need original text, use read_document_chunk).

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 provides explicit guidance on when to use the tool ('folder analysis starting point'), explains the meaning of the `allowed` flag in terms of downstream tool accessibility, and gives a clear example of when to use an alternative (read_document_chunk when the target file is known). This effectively routes the agent to the correct sibling tool.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false, and the description is fully consistent. Beyond those annotations it adds real context: the gating behavior (errors block the downstream approval token) and the return shape (valid/error_count/warning_count/issues[] with rule_id/severity/message/fix/line). No contradiction with 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?

Purpose and the critical gating consequence are front-loaded in the first two lines. Validation items are organized into error/warning lists, and Args/Returns sections are compact. Nothing is wasted; the whole definition 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 one fully documented parameter and an existing output schema, the description covers everything an agent needs: when to call it (before preview_save_report), what rules it enforces (with rule IDs and severities), and what it returns. No meaningful gap remains.

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

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

Schema coverage is 100% - the single parameter report_markdown is already documented in the schema as '검증할 요약 보고서 초안 전문(마크다운)'. The Args section merely restates it without adding new meaning, so the baseline of 3 applies. The validation-rule context lives in the description body, not in param semantics themselves.

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?

Uses a specific verb+resource (검사합니다/요약 보고서 초안 구조) and enumerates exact validation rules by severity (error: H1 + 5 required sections; warning: section order, placeholders, etc.). Clearly distinct from all 13 siblings as a structural pre-save validator.

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 frames the tool as a '저장 게이트' (save gate) and states the consequence: any error means preview_save_report won't issue an approval token. This routes the agent to call it before saving. It does not name alternatives like check_summary_grounding or diff_report_against_saved to clarify when those should be used instead, so it stops short of full exclusion guidance.

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