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

The description discloses useful behavioral traits beyond the annotations: it runs asynchronously, returns a pending status, and saves feedback history. These details align with the annotations (readOnlyHint=false, openWorldHint=true) and add context for the agent without contradicting the structured metadata.

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 for model selection, args, and returns. It front-loads the core purpose and keeps information focused; the parameter list slightly duplicates the schema but is not overly verbose.

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

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

Given the tool's moderate complexity (4 params, background execution), the description covers key aspects: return values, model options, API key handling, and side effects. The existence of an output schema further reduces the need for detailed return explanations, making this description 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?

The schema already provides descriptions for all parameters (100% coverage), but the description adds value by explaining model selection trade-offs (flash vs pro) and the API key fallback behavior. This goes beyond the schema's simple parameter labels and descriptions.

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

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

The description clearly states that the tool applies user feedback to a draft and runs in the background. It distinguishes itself from sibling tools like blog_apply_review_feedback by focusing on 'user feedback' on drafts, though it does not explicitly differentiate from the pro variant.

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 context about background execution and feedback history but gives no explicit guidance on when to choose this tool over alternatives such as blog_apply_feedback_pro. No conditions, exclusions, or comparative recommendations are 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 set readOnlyHint=false, indicating a mutation. The description adds valuable context: HTTP-only requirement, anthropic_api_key fallback to environment variable, and the return fields (task_id, status). It does not contradict 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?

The description is reasonably concise, starting with the key constraint '[HTTP 모드 전용]', followed by a directed warning, and organized Args/Returns sections. It is structured and not overly verbose, though it could be slightly tighter given the schema already documents the parameters.

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 description covers purpose, usage limitations, parameters, and return values. With an output schema present and a simple 3-parameter tool, this is nearly complete. However, it does not specify what happens to the draft after feedback is applied (e.g., whether it updates in place or triggers further processing), which would enhance completeness.

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

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

Schema description coverage is 100%, so the parameters are already fully documented (e.g., task_id '피드백을 적용할 Pro 작업 ID', feedback '수정 요청 사항', anthropic_api_key with env var fallback). The description's Args list repeats the same information without adding new semantic 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 clearly states 'Pro Mode로 생성된 블로그 초안에 피드백을 반영합니다' (applies feedback to blog drafts created in Pro Mode), which is a specific verb and resource. It also differentiates itself from the sibling tool blog_apply_feedback by the 'Pro' designation and Pro Mode mention.

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 explicitly states it is HTTP mode only, and warns Claude Desktop/Code users to use Claude directly instead, providing a clear alternative. It also ties usage to Pro-generated drafts, giving context for when this tool 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?

The description adds valuable behavioral context beyond annotations: it states the tool runs in the background, returns a status of 'pending', and references API key fallback to environment variable. These aspects are not captured in the annotations, which only provide basic hints (read-only, destructive, etc.).

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 for purpose, model selection, arguments, and returns. It is not overly verbose and front-loads the primary action, though it repeats parameter information already present in 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?

The description covers the key contextual aspects: asynchronous execution, return status, model options, and API key handling. It is sufficiently complete given the output schema and annotations, though it does not mention error conditions or prerequisites beyond the API key.

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 describes all parameters with 100% coverage, so the baseline is 3. The description goes further by explaining the trade-offs between model choices (flash for speed, pro for quality) and clarifying the default, which adds practical semantics beyond the schema's enum list and default values.

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 applies additional feedback to review results and runs in the background, using a specific verb and resource. However, it does not explicitly distinguish itself from the sibling tool 'blog_apply_feedback', which may serve a similar or overlapping purpose.

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 no guidance on when to use this tool versus alternatives. It only explains parameter options (e.g., model selection) but does not mention when to choose this tool over siblings like 'blog_apply_feedback' or 'blog_start_review'.

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 indicate the tool is not read-only, not destructive, and idempotent. The description adds valuable context by stating it 'directly commits' to the repository, requires a GitHub token, and works with static site generators. This goes beyond the annotations and informs the agent of the write behavior and authentication requirement.

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 a one-sentence summary, a list of parameters, and a return-value section. Every sentence adds meaningful information, and the format is easy to scan.

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 description covers the main input modes, required authentication, and return values, which is sufficient for a deployment tool. It does not mention edge cases like conflicting sources or precondition checks (e.g., repo existence), but the output schema exists and the description is still quite 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?

Although the input schema is empty, the description documents all eight parameters with their meanings, types, and optionality. It clarifies that task_id, content, and filepath are alternatives, repo and target_path are required, and branch defaults to main. This fully compensates for 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 uses a specific verb ('배포합니다' - deploys) and resource ('GitHub 저장소' - GitHub repository), clearly distinguishing this tool from sibling blog-management tools. It states exactly what it does: deploys blog posts to a GitHub repository via direct commits.

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 implies when to use this tool (final deployment of blog content to GitHub) and provides context about supported input methods (task ID, direct content, filepath). However, it does not explicitly mention alternatives or exclusions, but the purpose is unambiguous enough that an agent can infer the correct usage.

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. The description reinforces this by stating it returns the final result and that subsequent save/deploy tools are needed, making it clear this tool does not persist changes. This adds contextual value beyond the annotations without 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 compact and well-structured: a one-line action statement, a brief note about next steps, and simple Args/Returns sections. Every sentence serves a purpose, and the key verb is 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?

For a tool with one parameter, an output schema, and strong annotations, the description adequately covers the behavior and result. It identifies the completed-work requirement and the follow-up options, though it could be more explicit about prerequisites before finalizing.

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 input schema already provides 100% coverage for task_id with the description '확정할 작업 ID'. The Args section in the description repeats this exact information without adding any new meaning, so per the rubric the baseline score of 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?

The description opens with a specific verb+resource: 'Finalize blog draft' which clearly states the tool's function. It further explains it returns the final result of completed work, distinguishing it from sibling tools like blog_save and blog_deploy_github by noting those are subsequent steps.

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 clear context by stating that saving/deploying can be done later with blog_save or blog_deploy_github, implying this is the step before persistence. However, it does not explicitly say when to use this tool over alternatives like blog_start_review or blog_apply_feedback, so it lacks explicit 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, idempotentHint, and non-destructive behavior, covering safety. The description adds behavioral context by exposing the status values (pending, in_progress, completed, failed), which imply asynchronous task processing. This is useful beyond the annotations, though the return field list is likely duplicated in the output 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?

The description is well-structured and front-loaded with the primary purpose. However, the Args and Returns sections largely duplicate the input and output schemas, which reduces the efficiency. It is still concise enough for a simple tool, but some content could be trimmed without loss.

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 status-polling tool with a single parameter and an existing output schema, the description provides sufficient detail on the returned fields, including status and progress. It is slightly incomplete in that it does not mention the asynchronous nature explicitly, but the status values imply it. Overall, it is complete enough for an agent to invoke 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?

The input schema fully documents the single parameter (task_id) with the same description as in the Args section. Since schema coverage is 100%, the description adds no additional semantic value beyond what the schema already provides, aligning with the baseline score of 3.

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

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

The description clearly states the tool's function: to query task status ("작업 상태를 조회합니다"). This is a specific verb and resource, and it distinctly differentiates from sibling tools like blog_start_draft, blog_apply_feedback, and blog_finalize_draft, which all perform actions rather than status queries.

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 does not explicitly state when to use this tool or provide alternatives. The context of sibling tools implies it is meant for checking the status of asynchronous operations (e.g., after starting a draft), but this is only implied, not directly communicated. There is no guidance on when not to use it or how it fits into the workflow.

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 a non-read-only, idempotent, non-destructive operation. The description adds useful concrete behavior: local file storage, automatic filename generation from title/date, and directory fallback to BLOG_SAVE_DIRECTORY or ./posts. It does not mention overwrite behavior, but the idempotent hint reduces the need for that detail.

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 a well-structured, front-loaded docstring: a one-sentence summary, a brief usage note, bullet-style Args, and a Returns block. Every sentence earns its place and there is no redundant content.

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

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

The tool is simple, and the description covers the main workflow, directory defaults, and return values. However, it leaves ambiguity about whether task_id and content are mutually exclusive or if one is required, and the empty input schema makes the actual accepted parameters uncertain.

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 input schema declares zero properties, but the description compensates by documenting all four parameters (task_id, content, filename, directory) with concise explanations and defaults. This adds substantial meaning beyond the empty schema and is essential for correct invocation.

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 'Saves a blog post as a local markdown file,' a specific verb+resource pair. It also clarifies that the tool supports existing task IDs or direct content, clearly distinguishing it from siblings like blog_deploy_github and blog_get_status.

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 context about how to use the tool ('use existing task_id or directly enter content') and the default directory behavior, but it does not explicitly state when to prefer this over alternatives such as blog_finalize_draft or blog_deploy_github. Usage is implied rather than directly guided.

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 false, openWorldHint true), the description reveals that generation runs in the background, returns a task_id with status 'pending', and uses external APIs (Gemini, Notion). It also explains instructions_file merging behavior and web_search capability, providing rich behavioral context.

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 long but well-structured with clear sections for input_type, style, model, and instructions. It front-loads the primary purpose and provides necessary details for all 11 parameters without redundancy, though it could be slightly tighter.

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 complex tool with 11 parameters, background execution, external API dependencies, and an output schema, the description covers input types, styles, models, instructions, API keys, web_search, and return values. It also addresses prerequisites and file merging behavior, making it highly 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?

The description explains each input_type variant (keyword, code, memo, git_push, notion) with concrete use cases, elaborates on style options, and gives model selection guidance (e.g., flash for speed, pro for quality). This goes well beyond the schema's generic enum descriptions.

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: '블로그 초안 생성을 시작합니다' (starts blog draft generation) and mentions background execution. It distinguishes itself from sibling tools by focusing on initiating draft creation, and the title aligns with the description.

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 detailed guidance on how to configure input_type, style, model, and instructions, and notes when notion_api_key is needed. However, it does not explicitly mention when to use this tool versus alternatives like blog_start_draft_pro, or state exclusions/conditions for not using it.

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 indicate this is not read-only and may have open-world effects. The description adds context about the pipeline steps, but it incorrectly states web_search defaults to true while the schema says false, misrepresenting actual behavior. This is a transparency flaw despite no direct annotation 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 well-structured with headers and steps, but it duplicates the full argument list from the schema and includes a long warning block. It earns its place by providing mode-specific context, but could be tighter by removing redundant parameter details.

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 complexity of a multi-step pipeline, the description covers the workflow, mode constraints, parameter roles, and return values, and even references blog_get_status for follow-up. The only notable gap is the incorrect web_search default, which slightly reduces completeness.

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 baseline is 3, but the description actively misleads by claiming web_search default is true when the schema default is false. It also simply repeats the schema's parameter descriptions without adding meaningful new information, so it fails to add value and introduces confusion.

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 starts high-quality blog generation using a Claude Opus pipeline, and explicitly distinguishes itself as HTTP-mode-only, warning Desktop/Code users to use a different approach. This differentiates it from siblings like blog_start_draft and blog_get_status.

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 provides explicit when-to-use (HTTP mode) and when-not-to-use guidance (Claude Desktop/Code users should ask Claude directly), and even names blog_get_status for completion checking. This is exemplary usage 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?

The description discloses background execution, asynchronous return behavior (task_id, status pending), and the merge logic for instructions and instructions_file. It also mentions the Gemini API key requirement, which aligns with the openWorldHint annotation. No contradictions found.

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 sections and bullet points, but it repeats some parameter information (focus/model) in both the header sections and the Args list, creating minor redundancy.

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

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

The description covers purpose, parameters, return values, background execution, and API key authentication. It provides a complete picture for an agent, especially given the absence of schema-defined parameters.

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

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

Despite the input schema being empty, the description thoroughly documents each parameter with defaults and interactions. It explains the merging of instructions and instructions_file, fully compensating for the lack of schema-defined parameters.

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

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

The description clearly states that it starts a blog review in the background, using a specific verb and resource. It distinguishes itself from sibling tools like 'blog_start_draft' by focusing on the review action.

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 clear context on when to use this tool (for reviewing a draft or existing task) and hints at a workflow with prior drafting. However, it does not explicitly name alternative tools or exclusions, so it falls short of the highest tier.

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