jejusns

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the auth requirement but says nothing about return values, side effects, idempotency, or what happens on success/failure. For a mutation tool with zero annotation coverage, this is a notable gap.

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 permission note. Every word earns its place, though the brevity borders on under-specification given the missing behavioral and sibling-related context.

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, no annotations, and a close sibling (post_as_persona) that is not differentiated. The description does not explain the response format, how it differs from persona-based post creation, or any behavioral effects. Incomplete for an agent to confidently select and 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?

Schema description coverage is 100%, with title, content, and category_id all described in the input schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

The description '새 게시글을 작성합니다' (creates a new post) states a specific verb and resource, clearly distinguishing it from read/search siblings like get_post and search_posts. However, it does not differentiate it from the closely related sibling post_as_persona, which also creates posts but presumably with persona context.

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 includes a useful prerequisite ('write:posts 권한이 필요합니다' / requires write:posts permission) but provides no guidance on when to use this tool versus post_as_persona, no exclusions, and no alternative routing. An agent gets no decision support beyond the permission requirement.

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 no annotations, the description carries the burden and does well: it discloses the data source, dataset scale, that open_now is a server-side judgment based on Korean time, and exactly what each result contains (per-day hours, phone, coordinates). Gaps remain around pagination/truncation behavior and how holiday hours interact with open_now, but the core behavioral profile is clear.

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 compact sentences, front-loaded with what is searched and how large the dataset is, followed by filter hints and output/attribution guidance. Every sentence carries information, though the attribution instruction sits a bit awkwardly after the result-fields sentence.

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-optional-parameter search tool with no annotations and no output schema, the description covers purpose, source, key filter semantics, returned fields, and the page_url attribution requirement. Only pagination/limit behavior and total-result reporting are left unexplained, which is a minor gap given the schema documents limit.

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 all seven parameters are already documented, making 3 the baseline. The description only reinforces open_now semantics (server-side, Korean time) and gives a day='sun' example; it adds nothing for region, kind, name, emergency, or limit 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?

States a specific verb and resource with scope: searching Jeju clinics/hospitals (~1,000) and pharmacies (~300), sourced from National Medical Center public data. No sibling tool covers medical facilities, so the agent can immediately distinguish it from search_jobs, search_posts, or find_quiet_spots.

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

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

Gives concrete usage patterns — open_now=true for currently-open facilities, day='sun' for Sunday care — and instructs the agent to surface page_url as a source/detail link to the user. It does not state when-not-to-use or how to combine filters, but there are no competing siblings requiring routing 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?

With no annotations, the description carries the full behavioral burden and does most of it: it names the data source, the monthly granularity, the ≥100 monthly-arrival inclusion threshold for quiet mode, the sort direction, and the presence of a page_url/per-item url for sourcing. It even supplies the caveat the agent should relay about monthly aggregates differing from point-in-time congestion; what's missing is any note on result shape beyond the URLs or on response-time/rate characteristics.

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?

It is front-loaded with purpose, then mode semantics, then category handling, then the caveat/link guidance — a sensible order with no filler. It is a dense single paragraph, and the agent-directed 'relay this to the user' sentences add length, though they earn their place by shaping output behavior.

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 5-parameter, zero-annotation, no-output-schema tool, this is nearly complete: every parameter is touched and the return surface is partially described via page_url and per-item urls, with a mandated caveat about data granularity. It stops short of describing the record fields an agent would need to summarize results meaningfully.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning on top: the quiet-mode threshold and the practical 'fewest tourist arrivals' ordering, plus concrete category examples (카페, 쇼핑, 자연관광지, 해수욕장) that go beyond the schema's shorter example list. It does not explain region matching behavior, which the schema only partially covers.

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

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

The description uses a specific verb and resource (find less-crowded places in Jeju) and immediately qualifies it with the data's granularity: individual-destination navigation arrivals, monthly, split by tourist vs. resident. It also distinguishes itself from the sibling list_categories by naming it as the route for enumerating categories, so an agent can route correctly without opening the schema.

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

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

It states explicitly when to use quiet mode ('when looking for a calm alternative to a crowded attraction') versus busy mode ('tourist-arrival top ranking') and points to list_categories=true for the full category list. The only absent element is an explicit when-not-to-use, which is minor given how concretely the two modes are framed.

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 no annotations present, the description carries the burden of behavioral disclosure. It communicates that the operation is a read ('조회') and that admin rights are required, which is useful. It does not describe output format, report scope, potential failure behavior, or whether the statistics are aggregated or filtered in any way.

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 extremely concise: two short sentences with no filler or redundant information. It front-loads the core purpose and immediately states the key access requirement, which is appropriate for a tool with no 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?

For a zero-parameter read-only tool, the description provides a usable baseline: the agent knows what to call and under what permission condition. However, there is no output schema and the description does not explain what the returned ad performance statistics will include, which leaves some ambiguity about expected results.

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

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

The input schema has zero parameters and 100% schema description coverage, so there are no parameter semantics for the description to clarify. The baseline for a no-parameter tool is 4, and the description correctly does not invent parameter details.

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 identifies the action ('조회합니다' / retrieves) and the resource ('광고 성과 통계' / ad performance statistics), so an agent can understand what the tool does. It does not explicitly differentiate it from sibling stats tools like get_site_stats or get_price_stats, but the ad-specific resource is reasonably distinctive.

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 mentions an admin permission prerequisite, which is a form of usage constraint. However, it provides no guidance on when to use this tool over the related statistics tools or which conditions should trigger this tool versus get_site_stats/get_price_stats.

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 no annotations, the description carries full behavioral disclosure burden, but it only says 'fetch latest feed' and 'category filter possible.' It does not disclose read-only nature, ordering behavior, default pagination, category matching semantics, or what the response contains.

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 Korean sentences are tightly packed: resource, action, and key capability. 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?

For a read tool with no annotations and no output schema, the description is thin. An agent still does not know what a feed entry looks like, how categories are matched, or how pagination behaves.

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 schema already documents page, limit, and category. The description adds only the category filtering concept, which is useful but not substantial enough to exceed the baseline 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?

Description states a specific action ('가져옵니다' / fetch) on a specific resource ('제주돌담 최신 피드' / latest Jeju DolDam feed), with category filtering. This clearly distinguishes it from siblings like get_post (single post) and search_posts.

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 it is for browsing the latest feed with an optional category filter, but it does not explicitly state when to choose this over search_posts/search_property_listings or any exclusions. No alternative tools are named.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. The verb '조회' and tool name 'get_post' imply a read-only operation, and '전체 내용' indicates the response scope. But it does not mention authentication needs, post visibility rules, or potential side effects. The gap is moderate for a simple read tool.

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 one short declarative sentence that front-loads the action and resource. There is no redundancy, filler, or repetition of schema 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?

For a one-parameter read operation with no output schema, the description is nearly complete: it identifies the lookup key and states that the full content is returned. It lacks explicit response structure and error semantics, but those are not essential for basic 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 single required parameter 'id' is already fully documented in the input schema with type, format, pattern, and a Korean description, giving 100% schema description coverage. The description adds no additional semantic meaning beyond the schema, so 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 uses a specific verb and resource: '게시글 ID로 전체 내용을 조회합니다' (retrieve full content by post ID). It clearly scopes the operation to a single post identified by ID, which distinguishes it from search-oriented siblings like search_posts or get_feed.

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 usage context is implied: use this tool when you already have a post UUID and need the full post content. However, it does not explicitly state when not to use it or point to alternatives such as search_posts, get_feed, or get_user_profile.

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 no annotations, the description carries the full disclosure burden and does well: it identifies the authoritative data source, implies reporting lag via '신고 데이터', documents the suppressed/fallback_region edge case, and states that responses include page_url or per-item url. It omits pagination, response size, and any latency or rate-limit 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 purpose and data-source caveat are front-loaded, and each subsequent sentence handles a distinct case (no region, suppressed sample, page_url). It is dense with instructions but no sentence is redundant; slight tightening would earn a 5.

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

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

For a one-parameter statistics tool with no output schema, the description covers the key unknowns: what the data source is, what happens with no region, how to handle suppressed regions, and what URL fields are returned. An agent can call this and interpret the response correctly without further information.

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

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

Schema coverage is 100% and the single region parameter is fully documented in the schema, including the omit-to-list-regions behavior, so the baseline is 3. The description reinforces the omitted-region semantics but adds no new format or matching details beyond what the schema states.

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 precisely: 제주 아파트 실거래 시세 통계, sourced from 국토교통부 실거래 신고 데이터, explicitly excluding asking prices (호가 아님). This cleanly separates it from listing-oriented siblings such as search_property_listings or upsert_property_listing, though no sibling is named outright.

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 states a clear conditional usage path: call without region to get the list of supported regions, and on suppressed=true re-query with fallback_region rather than reporting 'no data'. It also tells the agent to surface page_url to the user. The only gap is that no alternative sibling tool is suggested for adjacent tasks.

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?

There are no annotations, so the description carries the burden. It discloses the admin authorization requirement and implies a read-only stats retrieval through 'statistics'. It does not describe return formatting or side effects, but for a zero-parameter stats endpoint the permission note is the key behavioral trait.

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 states the resource, gives representative contents, and notes the access requirement. Every element earns its place with no redundancy.

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

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

For a no-argument, no-output-schema tool, the description is largely complete: it identifies the data domain, representative return values, and admin restriction. It does not document the exact response schema, but the examples are enough for an agent to invoke and interpret results.

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

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

The tool has zero parameters, so the baseline for parameter semantics is 4. The description adds no parameter details, but none are needed because the schema already shows an empty properties object and the description covers the resource.

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 the resource ('site-wide statistics') and gives concrete contents (user, post, and comment counts), distinguishing it from siblings like get_ad_stats and get_price_stats by the word 'site-wide'. The verb is implicit in the tool name, but the noun and examples make the purpose 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?

It gives clear context: use this when overall site-wide counters are needed, and it warns that admin permission is required. It does not explicitly contrast with sibling tools or state when not to use it, so it stops short of a 5.

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 no annotations, the description carries the full burden and does so well: it discloses the data source and monthly SKT-based aggregation, the non-real-time nature, the behavior when region is omitted, automatic mapping between 행정동 and 법정동 names, and the no_data/available_regions fallback path. It even tells the agent to surface page_url as a source link, which is behavior beyond any structured field.

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 scope are front-loaded in the opening sentence, followed by source/caveats, default behavior, naming behavior, error handling, and link guidance in a logical order. Every sentence carries operational value; nothing 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 single optional parameter with no output schema, the description covers everything an agent needs: what is returned, the shape of the default call, the no_data contract with available_regions, and the page_url field. Missing structured return documentation is compensated for by describing response fields in prose.

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 a baseline of 3 already applies, but the description adds real meaning: legal-dong names (용담이동) are auto-mapped to the platform's administrative-dong notation (용담2동), and omitting the parameter returns the full list. This is semantic behavior the schema does not convey.

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 first sentence states a specific verb+resource+granularity: monthly visitor statistics by 읍면동, with domestic/foreign split and month-over-month/year-over-year comparisons. It is clearly distinguishable from sibling stats tools (get_site_stats, get_ad_stats, get_price_stats) because the tourism/visitor domain and the geographic unit are named explicitly.

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

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

It gives strong usage context: the data is not real-time, so the agent should describe monthly patterns rather than 'crowded right now', and an omitted region returns the whole township list for the latest month. It does not explicitly name sibling tools to use instead for real-time crowding (e.g. find_quiet_spots), so routing guidance is implied rather than complete.

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?

No annotations are provided, so the description carries the full burden for behavioral disclosure. It does indicate that this is a read operation ('조회') and that results are limited to public profile data with personal information excluded, which is useful. However, it does not describe response format, authentication, or error behavior, leaving some behavioral ambiguity.

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 single concise sentence that front-loads the core action and then adds the important privacy qualifier. Every word earns its place, and no redundant detail is present.

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

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

For a simple one-parameter read tool without an output schema, the description provides enough context to select and invoke the tool: it identifies the resource, the public scope, and the key privacy exclusion. It does not enumerate return fields, but that is a minor gap for a standard profile lookup task.

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

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

Schema coverage is 100% and the single user_id parameter is already described as '사용자 UUID' in the schema. The tool description adds no additional parameter meaning, so 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 states a clear operation ('retrieves') and a clear resource ('public user profile'), and further narrows scope by excluding personal information such as email. This is specific enough to distinguish it from the sibling get_* tools without requiring schema inspection.

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 no guidance on when to use this tool versus alternatives. There is no mention of when to prefer get_user_profile over get_feed, get_post, or other profile-related operations, so the agent must infer usage purely from the tool name and context.

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 no annotations provided, the description carries the full burden, and it does clearly convey a read-only, side-effect-free operation by saying it 'returns' data. It also discloses the key behavioral output: the category list and per-category post counts. It does not mention ordering, pagination, or whether empty categories are included, but for a simple no-parameter listing tool this is a minor gap.

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 single, focused sentence that states the resource and the returned data without any filler. It is front-loaded with the core purpose and includes the useful count detail without expanding into unnecessary explanation.

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 low-complexity, no-input tool with no output schema, the description provides enough information to understand what will be returned: categories and their post counts. It is slightly incomplete in not addressing ordering, pagination, or whether the counts are live, but these are not critical for an initial call to this kind of endpoint.

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 and the input schema is empty, so there are no parameter semantics for the description to clarify. The baseline of 4 applies because there is nothing ambiguous about inputs, and the description does not need to compensate for any schema gaps.

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 identifies the operation as returning the category list of Jeju-doldam and includes the additional detail of post counts per category. This is specific enough to distinguish it from sibling tools like get_post, get_feed, and search_posts, which deal with individual posts or feeds rather than category metadata.

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 when an agent needs to discover available categories and their post counts, but it does not explicitly state when to use this tool versus alternatives. It provides no exclusions or comparative guidance against sibling tools, so the agent must infer the appropriate context from the name and description.

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?

Since no annotations are provided, the description carries the burden of behavioral disclosure. It describes the return contents and the intended preflight role, and the list/return framing strongly implies a read-only operation. It does not explicitly state auth needs, rate limits, or absence of side effects, but for this simple list tool the disclosure is adequate.

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 two sentences with no filler. The first sentence states the return value and included fields; the second gives the concrete use case. Information is front-loaded and every sentence 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?

For a zero-parameter list operation with no output schema, the description is complete: it states what is returned, which fields matter, and when to call it. The explicit field names compensate well for the absence of an 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?

The tool has zero parameters, so the baseline of 4 applies. There are no parameter semantics for the description to explain, and the empty schema already fully covers the parameter surface.

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 list of persona accounts by category, and explicitly names the included fields (posted_today, category). This clearly distinguishes it from sibling tools like list_categories and post_as_persona.

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 a concrete workflow instruction: call this before post_as_persona to identify which personas have not posted today. This is clear context, though it does not mention when not to use the tool or name alternative tools beyond post_as_persona.

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 no annotations provided, the description carries the full disclosure burden. It does disclose two meaningful behavioral traits: admin authorization is required and the tool is reserved exclusively for automated (Claude cowork) posting, both of which gate whether an agent may invoke it. What is missing is the outcome of a successful call — whether the post is immediately published, rate limits, or error behavior — so the disclosure 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, each carrying a distinct piece of information: the action, the prerequisite/discovery step, and the exclusive use case. It loses a point for minor redundancy — the persona email format and the category-UUID lookup source are already documented in the schema property descriptions, so those fragments add no new 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?

For a four-parameter write tool with no annotations and no output schema, the description covers the essentials: the action, the permission requirement, the parameter-value discovery path, and the exclusive usage scope. The main gap is that it never describes the expected result of a successful call, and with no output schema there is nothing else to fill that in — but an agent has everything needed to select and 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?

Schema description coverage is 100%, so the baseline is 3, but the description adds genuine value beyond the schema by prescribing the discovery workflow: use list_personas to obtain both the persona email and the category UUID before calling. This materially improves the probability of a valid invocation, justifying a 4.

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/writes), a clear resource (게시글 — post), and the defining scope: posting as a specific persona account (persona.xxx@jejusns.com). It also distinguishes itself from siblings by declaring it an auto-posting-only (자동 포스팅 전용) tool, so an agent can tell it apart from create_post 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 gives concrete prerequisites — 'admin 권한이 필요합니다' (admin permission required) — and an explicit discovery step: run list_personas first to obtain persona emails and category UUIDs. It also scopes usage to automated Claude cowork posting. However, it never names create_post as the alternative for manual or non-persona posting, so the when-not-to-use guidance is implicit 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?

No annotations are supplied, so the description carries the full burden. It adds real domain behavior — wages are KRW interpreted jointly with wage_type, and undisclosed wages surface as wage_type='협의' — plus a post-call obligation to cite page_url/url. It omits pagination/result-size behavior, ordering, and any explicit statement that this is a read-only operation.

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: purpose, filter scope, wage semantics, then the page_url attribution instruction — front-loaded and free of padding. The final attribution sentence is somewhat operational rather than definitional but still earns its place for correct output handling.

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 six-parameter search tool with no output schema and no annotations, the description covers purpose, filter scope, value interpretation, and the shape of the response link (page_url / per-item url). Remaining gaps — pagination, default limit, ordering — are minor for a filtered list 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 67%, and the description compensates well for the gap by explaining the unit and coupling of wage_min/wage_type and decoding the '협의' enum value, which the schema leaves undocumented. It does not address limit bounds or the include_closed default, but the highest-ambiguity parameters are covered 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 specific verb + resource ('구조화된 제주 채용 공고를 필터로 검색합니다') and immediately names the filter dimensions, so an agent knows this is a filtered search over Jeju job listings. It is clearly distinct in substance from search_posts or the job-listing write tools, though it never explicitly differentiates itself from those siblings by name.

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 by the filter list ('지역·직종·급여 필터 지원') and the closing instruction to surface page_url to the user, but there is no explicit when-to-use/when-not guidance, no mention of alternatives such as search_posts, and no note on defaults like include_closed=false driving result choice.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It usefully discloses that space-separated words are combined with AND and that category accepts either a Korean name or UUID. The verb '검색' implies a non-mutating read operation, but the description does not mention result ordering, whether matching applies to title/content/both, or pagination behavior beyond the schema's limit parameter.

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 with no filler. The first sentence front-loads the core purpose, and the second packs two useful semantic details (AND behavior and category format). It is appropriately concise for a simple search 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 straightforward search tool with 3 simple parameters and no output schema, the description is nearly complete: it specifies search target, query combination behavior, category format, and the schema covers limit. The only minor gap is not explaining what the returned results look like or how they are ordered, but this is not critical for a search action.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining that multiple whitespace-separated words in the query parameter are all required (AND semantics), which is not stated in the schema. The category-as-name-or-UUID detail is redundant with the schema but reinforces expected usage.

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 a specific verb and resource: 'Search Jeju Dol-dam posts by keyword.' It is distinct from sibling search tools like search_jobs and search_property_listings because of the explicit '제주돌담 게시글' scope, and from get_post/get_feed through the keyword-search action. However, it does not explicitly name any sibling to differentiate itself.

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 no guidance on when to choose this tool over alternatives. It does not mention that get_post is for retrieving a single post or get_feed for browsing posts, nor does it state any exclusions. The AND semantics and category format are about how to use parameters, not about when to use the 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?

With no annotations, the description carries the full burden. It usefully discloses that the response contains page_url (or per-item url) pointing to a jejusns.com page and instructs the agent to surface it to users, which is genuine return-content information. It does not state default sort/limit behavior, result pagination, or that the operation is a non-mutating read, though '검색' implies read-only.

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

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

Front-loaded with the core action, then compact sentences each covering a distinct need (units, region format, rent-parameter routing, link attribution). No filler or restatement of the 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?

For a 13-parameter read tool with no annotations and no output schema, the description covers the highest-risk ambiguities (currency scale, region naming, monthly vs yearly rent params, response link) and explains the returned URLs. It is slightly thin on default ordering/limit and overall result shape.

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

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

Schema coverage is 69%, and the description adds real value: the KRW conversion example ('3억 → 300000000'), Hangul region examples, and the domain note that 연세 is a Jeju-specific annual-rent term distinct from 월세. Remaining parameters (sort, limit, price_min/max, area_min/max, include_expired) are left to the schema.

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

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

The description states a specific verb and resource ('구조화된 제주 부동산 매물을 필터로 검색합니다') and enumerates the filter dimensions (지역·매물유형·거래유형·가격·면적), which cleanly separates it from sibling tools such as search_jobs, search_posts and get_price_stats.

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 direction: use monthly_max for monthly-rent ceilings and yearly_max for the Jeju-specific yearly-rent ceilings, pass prices in KRW, and use Hangul place names. It never states when not to use this tool or points to an alternative such as get_price_stats/get_ad_stats for aggregate statistics.

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 no annotations, the description carries the full burden and does well: it discloses the required write:listings key, the key-owner identity restriction, the minimum-wage validation rule, and the fact that the first call returns a preview plus warnings rather than publishing. It stops short of saying what happens after publication (moderation, immediate visibility) or what errors look like.

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, then constraints, then a numbered two-step procedure — a well-ordered structure. The text is dense but nearly every clause carries operational information; only the minimum-wage figure and the '협의' rule could be argued as schema-adjacent detail.

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 13-parameter mutation tool with no annotations and no output schema, the description covers the critical unknowns: auth, validation floor, dry-run default, and the confirmation handshake. It is not fully complete because it omits sibling differentiation and any statement about what a successful publish returns or how failures 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 coverage is 62%, and the description compensates for the undocumented fields: it explains that wages are KRW integers, that hourly wage must meet 10,320 KRW, that wage_type='협의' is used for undisclosed pay, and it defines the dry_run/confirmed_by_user pairing as a safety protocol. The remaining required fields (employer_name, contact_phone, occupation) get no added meaning beyond their schema entries.

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: registers an employer's Jeju job listing on jejusns.com. It is clear what the tool does, but it never distinguishes 'submit' from the sibling 'upsert_job_listing', so an agent must guess which one creates vs. updates.

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 two-step workflow with a hard prohibition ('do not call dry_run=false without user approval') and states the default dry_run=true behavior. The gap is that it never routes the agent away from upsert_job_listing or toward search_jobs for verification, so sibling selection 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?

With no annotations, the description carries the full burden and does well: it discloses the required write:listings key, that the key owner's identity is used, that the server constructs the listing body from the input fields, and that the dry run returns preview plus warnings. It leaves unstated what a successful publish returns and whether a submitted listing becomes immediately public.

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, units, and the two-step protocol appear in that order with no filler; every sentence either prevents a misuse (currency mix-up, unapproved publish) or explains a default. The numbered (1)/(2) structure makes the sequence easy to follow.

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 19-parameter mutation tool with no annotations and no output schema, the description covers the critical surfaces: authorization, units, server-side body construction, and the confirmation gate. It is thin only on post-success behavior and on how it relates to 'upsert_property_listing'.

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 74%, so the schema already explains most fields, including dry_run and confirmed_by_user. The description adds a real unit conversion example (3억 → 300000000) and the fact that no free-form body needs to be assembled, but contributes nothing on the six required fields or the broker-specific 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 opens with a concrete verb+resource+destination: registering the caller's own Jeju real-estate listing on jejusns.com, with the ownership scope ('본인 매물', key owner's name) stated explicitly. It is not distinguished from the sibling 'upsert_property_listing', which is a plausible source of confusion between create-only and create-or-update semantics.

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 prescribes an exact operating procedure: first call with dry_run omitted, show the returned preview and warnings verbatim, ask for approval, then re-call with dry_run=false and confirmed_by_user=true. It also states a hard prohibition ('사용자 승인 없이 dry_run=false 로 부르지 마세요'), so both the when and the when-not are unambiguous.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It does add meaningful context: admin-only access, required call ordering after post_as_persona, and the salary-privacy encoding rule. However, it does not disclose upsert semantics, whether existing records are overwritten, authentication requirements beyond 'admin', or any side effects, leaving notable 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?

The description is two sentences with no filler. It front-loads the admin constraint, then gives the sequencing instruction, then the key salary rule. Every sentence earns its place and the structure is easy to parse quickly.

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 14-parameter mutation tool with no annotations and no output schema, this description is not complete enough. It provides valuable orientation but omits upsert behavior, parameter semantics for most fields, what happens on conflict, and any expected response. An agent has enough to attempt the call, but not enough to invoke it confidently and safely across realistic variations.

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 only 29%, so the description must compensate for undocumented parameters. It adds a valuable rule for wage_type, wage_min_krw, and wage_max_krw (KRW integer, use 협의 and omit amounts when private), but most of the 14 parameters remain unexplained, including post_id provenance, source_name/source_ref/source_url, and contact fields. The compensation is too partial for the low schema coverage.

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 action ('저장합니다' / saves) on a specific resource ('채용 게시글' / job posting structured data), which clearly distinguishes it from sibling upsert_property_listing. It does not explicitly explain the 'upsert' (create-or-update) behavior, but the tool name and resource make the purpose reasonably clear.

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

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

The description gives a clear usage context: it is admin-only and should be called right after post_as_persona. This is actionable sequencing and access guidance. It does not explicitly state when not to use it or name alternatives, but the job-listing scope makes the intended use unambiguous.

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 no annotations, the description carries the behavioral disclosure burden. It adds useful data-handling commitments (KRW integers with a conversion example; source_url is internal and never public), but it omits upsert semantics (what happens when post_id already exists), authorization failure behavior, and any side effects beyond saving.

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 sentences in Korean, each carrying a distinct piece of information: purpose/scope, invocation timing, and shared field semantics. 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?

The definition covers the essential workflow and the two most important behavioral conventions (currency units and private field), which is enough for a routine follow-up call. However, for a write tool with 17 parameters and no output schema/annotations, it should also state upsert conflict behavior, applicable fields per deal_type, and what the tool returns; these gaps keep it at minimum viable.

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 65%, and the description adds cross-parameter meaning: all money fields must be KRW integers (7,300만원 → 73000000) and source_url is private. It also ties parameter usage to 'same fields' as post_as_persona, which helps the agent populate fields; however, a few schema-undocumented fields (floor, rooms, building_name, contact_phone) remain unexplained.

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 ('저장합니다' / saves), a clear resource ('부동산 게시글의 구조화 데이터' / structured real-estate post data), and an admin scope. It is clearly distinguishable from the sibling search_property_listings because it writes rather than reads, and the pipeline mention of post_as_persona reinforces the intended 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?

Explicitly tells the agent to call this immediately after post_as_persona and send the same fields, which is a concrete when-to-use condition. It also notes admin-only access, but it does not enumerate when-not-to-use or point to alternatives such as upsert_job_listing.

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?

No annotations are provided, so the description carries the full load, and it does disclose the meaningful auth constraint that only the key owner's own posts can be withdrawn. It does not say whether the takedown is reversible or a hard delete, whether the post disappears from search/feed results, or what happens when the ownership check fails, leaving the mutation semantics partly opaque.

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 consists of a single front-loaded sentence plus a short constraint clause, with no filler. The example causes are compressed into a parenthetical, which keeps the definition short while still adding 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?

This is a destructive mutation tool with no annotations and no output schema, so the description must cover safety and effect on its own. It covers purpose, justification, and ownership scope, but omits reversibility, effect on downstream listings/feeds, and failure behavior, which is a real gap for a takedown operation.

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 50%: post_id is documented in the schema as 'submit_* 가 돌려준 post_id', while reason has an enum but no description. The description never mentions the reason parameter or explains that the withdrawal causes it lists ('거래완료', '마감', '잘못 등록') correspond to the enum values, so it contributes almost nothing 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 uses a specific verb and object phrase ('이 키 주인이 올린 매물·공고를 내립니다') and adds a scope qualifier ('본인 글만 가능합니다'), so an agent can tell what is being changed and whose content it touches. It is not identical to any sibling, though it never names the counterpart submit_property_listing or submit_job_listing to make the pairing 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?

Parenthetical examples ('거래 완료·마감·실수 등록') tell the agent the situations that justify calling it, and '본인 글만 가능합니다' states a precondition. The description does not name an alternative tool or say what to do when the post does not belong to the key owner, so there is no coverage of when not to use it.

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