MarketPilot

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

Annotations already declare destructiveHint=true, so the destructive nature is covered. The description adds a behavioral constraint: it only works on PENDING requests. This is a meaningful addition beyond the annotation, though it doesn't disclose potential errors or irreversibility details beyond what the annotation implies.

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, front-loaded sentence with no wasted words. It states the action and condition immediately, making it easy for an agent 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 simple single-parameter cancellation with no output schema, the description covers the core purpose and condition. It doesn't mention error handling or response format, but given the low complexity and annotations covering destructiveness, it is mostly complete. A minor gap is not explaining what happens if the request is not in PENDING state, but that's an edge case.

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% (chargeRequestId is described as '충전 신청 ID'). The tool description adds no additional parameter context, so it does not exceed the baseline of 3 when the schema already documents the parameter.

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

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

The description clearly states a specific action (cancel) on a specific resource (charge request) with a condition (PENDING status). This distinguishes it from sibling tools like request_point_charge (create) and get_charge_request (read). The verb-resource pair is unambiguous.

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

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

It provides a clear context for use: only when the charge request is in PENDING status. This implies the tool is not appropriate for non-pending requests, but it does not explicitly name alternatives or state exclusions. The condition is a useful guideline, though it doesn't contrast with other tools directly.

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

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

The description discloses critical behavioral facts beyond the annotations: creating the link does not charge money (payment happens on the link), the server calculates the amount (unit price cannot be entered), and no membership is required. It also specifies that the response contains a checkoutUrl to show to the user. These details significantly exceed the sparse annotations and help the agent understand the tool's side effects.

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 paragraph but contains multiple sentences, each contributing useful information: purpose, server-side amount calculation, response usage, payment flow, and pre-creation confirmation steps. It is front-loaded with the core purpose and organized logically, though slightly long. 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?

Given there is no output schema, the description's mention of checkoutUrl is essential and provided. It covers the full flow from creation to user payment, including important prerequisites like user confirmation and name collection. It does not detail optional parameters or error cases, but the schema covers optional fields, so the description is sufficiently complete 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?

Schema description coverage is 100%, so all parameters are already documented. The description adds value by clarifying that only product ID and quantity are needed and that the server computes the amount, ruling out unit price as a parameter. It also emphasizes that customerName must be obtained from the user, reinforcing its requirement. This goes beyond the schema's basic field 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 it creates a payment link for card payments, using the verb '만들다' (create) and resource '결제 링크' (payment link). It is unambiguous and distinct from sibling tools like get_checkout_status (which checks status) and signup (which handles registration).

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 for when to use the tool (to create a payment link) and gives specific instructions: confirm product, quantity, and expected amount with the user before creating, and ask for the customer name directly. It also warns that creating the link alone does not charge the user. However, it does not explicitly mention alternatives like 'use get_checkout_status to check status', 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 indicate a write operation but not destructive. The description adds the crucial side effect that points are deducted immediately, which is not present in annotations. This goes beyond structured data and alerts the agent to a significant consequence.

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 fluff. The purpose and the critical warning are front-loaded, and every word 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 tool with 6 parameters and no output schema, the description covers the essential flow but omits any information about the return value or error conditions. It also doesn't explain the role of formData and templateOption, though these are partially in schema. Adequate for the core behavior but not fully comprehensive.

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 83%, so most parameters have descriptions. The description adds the requirement that confirm must be true after user confirmation, but does not clarify formData or templateOption beyond schema. It adds marginal value over 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 action (create order) and explicitly labels it as step 2 of the order flow, distinguishing it from quote_order and other order-related siblings. The title '포인트 주문 확정' reinforces the 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?

Gives clear usage context: it is the second step after quote, and requires user confirmation before calling with confirm:true. It also warns about immediate point deduction, which is a key decision factor. However, it does not explicitly name alternative tools or 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 already declare readOnlyHint=true and destructiveHint=false, so the description need not repeat safety. It adds behavioral context about the deposit-to-CONFIRMED status transition, which is not in annotations. This helps the agent understand the expected flow and what the tool is designed for.

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, compact sentence that front-loads the purpose and then provides the use case. No wasted words; every part 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 simple getter with one parameter and no output schema, the description covers the purpose and usage scenario. The annotations cover safety, and the description's mention of CONFIRMED status implies the response includes status. Nothing essential is missing 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 input schema fully describes the single parameter (chargeRequestId) with a description '충전 신청 ID', so schema coverage is 100%. The description does not add any extra information about the parameter beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool checks the status of a single charge request (충전 신청 1건의 상태를 확인합니다) and explicitly mentions the purpose of verifying whether status becomes CONFIRMED after deposit. This distinguishes it from list_charge_requests (listing multiple) and cancel_charge_request (cancelling). The verb '확인' and resource '충전 신청' are specific and unambiguous.

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

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

The description provides clear context: it is used after a deposit to check if status changed to CONFIRMED. This implies when to use it (post-deposit verification). However, it does not explicitly name alternatives or state when not to use it, but the context is sufficient to differentiate from sibling tools like list_charge_requests.

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

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

Annotations already cover read-only/idempotent/non-destructive behavior. The description adds concrete status values (대기·완료·만료), includes order progress, and provides agent guidance for the setupUrl branch—valuable beyond annotations.

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

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

Two sentences: the first front-loads the purpose and scope, the second gives the trigger and follow-up instruction. No filler or redundant 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-only single-parameter tool, the essentials are present: what statuses to expect, that order progress is included, and the setupUrl follow-up. No output schema exists, but the description compensates reasonably; slightly more detail on return shape would make it fully 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 schema already fully documents checkoutToken with 100% coverage, including its origin from create_checkout. The description adds no new parameter-level syntax, but none is needed here.

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

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

States a specific verb '확인합니다' and resource: payment link status and post-payment order progress. This clearly distinguishes it from create_checkout and the other siblings.

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

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

Provides an explicit trigger ('사용자가 결제했어요라고 하면') and a follow-up action for setupUrl. It does not explicitly name alternatives or exclusions, but the usage context is clear.

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

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

The description adds behavioral context beyond the readOnlyHint/destructiveHint annotations by listing the returned fields, explaining the progress status flow, noting that progress only appears for provided products, and stating that recentLogs are in latest-first order. It also provides conditional guidance for null progress, which helps an agent anticipate responses.

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 front-loaded with the core purpose, followed by return-field details and a concrete usage example. Each sentence earns its place, though the second sentence is somewhat dense and could be split for readability.

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

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

With no output schema, the description compensates by enumerating the key returned fields (status, statusLabel, phaseLabel, progress, recentLogs) and their semantics. It is sufficient for a simple read-only single-order lookup, though it does not describe edge cases like missing/unknown orderId or authentication requirements.

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%: the single orderId parameter is already described as '주문 ID (list_my_orders의 orderId)'. The description adds no additional parameter-level meaning, so the baseline 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 clearly states a specific verb and resource: retrieving the progress of a single order (주문 1건의 진행 상황을 조회합니다). It differentiates itself from list_my_orders through the '1건' singular scope and the focus on progress fields, though it does not explicitly name any sibling alternative.

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

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

The description gives an explicit when-to-use trigger: questions like '내 주문 어떻게 돼가?' and explains how to handle a null progress field (use statusLabel and recentLogs). However, it does not state when not to use this tool or name alternatives such as list_my_orders or get_checkout_status.

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 and destructiveHint=false, so those are covered. The description adds the useful unit and payment-behavior context, but does not disclose response shape, whether the balance is for the current user, or any rate-limit/auth considerations.

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: the first states the operation, the second provides the essential 1P-1KRW relationship and point-payment behavior. Every sentence earns its place with no filler or 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 zero-parameter read-only balance lookup, the description plus annotations cover most needs. It is slightly incomplete because it doesn't explicitly state whose balance is returned or what the response looks like, but the unit context and safe-read annotations make it sufficiently actionable.

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 and schema coverage is 100%, so the baseline is 4. The description adds no parameter-specific meaning because there are no parameters to document; its unit context is the only relevant semantic addition.

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 ('조회합니다' – retrieves) and a precise resource ('포인트 잔액' – point balance). It also adds essential context (1P = 1 KRW, orders are paid with points), making the tool's role distinct from charge, order, and checkout siblings.

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

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

No explicit when-to-use guidance or alternatives are given. The point-payment context implies the tool is for checking balance before ordering, but it never tells the agent to prefer this over related tools like request_point_charge or get_charge_request.

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, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds real behavioral value beyond that: it exposes that the response includes a match score with per-condition judgments, and — most importantly — that the agent cannot act on the bid itself and must hand the user off to sourceUrl. It stops short of describing pagination or error behavior, which are not relevant for a single-record fetch.

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 definition is short and front-loaded: the field list comes first, followed by the action guidance. Every sentence carries content, though the participation hand-off could be tightened slightly.

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

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

With no output schema, the description correctly enumerates what the call returns, and it covers the key behavioral constraint that participation is out-of-band. The only meaningful gap is the undocumented profileId parameter, which affects the match-score result the description promises.

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 says nothing about the two parameters. bidId is documented in the schema (including the sibling tools it comes from), but profileId has no description in either the schema or the description, leaving that parameter's meaning completely unexplained at 50% 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 names a specific verb and resource (retrieve the details of a single bid announcement) and enumerates the returned fields (estimated price, deadline, opening, contract method, region/industry restrictions, qualification deadline, match score). This distinguishes it from the plural siblings search_procurement_bids and list_procurement_matches, though the distinction is implied via '1건' rather than stated 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 tells the agent what to do after fetching (guide the user to sourceUrl) and clarifies that bid participation happens manually on Nara Market, which is genuinely useful routing guidance. However, it never states when to call this tool versus search_procurement_bids or list_procurement_matches, so the selection guidance remains implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context by specifying what the tool returns (unit price, quantity constraints, formFields) and its role as a prerequisite for checkout.

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 short sentences with no redundant phrasing. The core purpose is front-loaded, and the usage reminder is placed after the primary definition, making it 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?

For a simple single-parameter read tool, the description is complete: it explains what data is returned, why it matters (checking quantity constraints before payment link), and the parameter is fully documented. An agent has enough information 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 coverage is 100%, and the single productId parameter has a description that cross-references list_products. The tool description adds no additional parameter-level detail, so the baseline 3 is appropriate since the schema already handles the semantics.

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 fetches one product's details (unit price, quantity constraints) and the formFields needed for execution, using a specific verb ('조회합니다'). It also differentiates from sibling list_products by emphasizing single-product detail and checkout-related data.

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

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

The description gives explicit usage context: check quantity constraints before creating a payment link. It does not explicitly name alternatives or exclusions, but the 'before payment link' guidance makes the intended scenario clear enough.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower. The description still adds real context: the response contains applyUrl, a personal matching score, per-condition judgments, and the isContest flag semantics, plus the explicit note that the tool does not submit an application — a non-obvious behavioral boundary.

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 purpose in the first clause, then follow-up guidance on applyUrl and contest handling. Every sentence is relevant, though the contest/label instruction is a bit conversational and could be tightened 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?

With no output schema, the description carries the burden of describing returns and does so well (content, eligibility, applyUrl, matching score, condition verdicts, contest flag). The only gap is how a caller first obtains a programId, which is relegated to the schema rather than stated in the description.

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 programId and profileId are already fully documented, including where programId originates and that profileId defaults to the representative profile. The description adds no additional parameter meaning, 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?

States a specific verb (조회합니다) and resource (지원사업 공고 1건의 상세), and enumerates what comes back: 지원 내용, 자격 요건, applyUrl, 매칭 점수, 조건별 판정. This clearly separates it from the list/search siblings like list_support_matches and search_support_programs, which surface many programs rather than one detail.

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 downstream guidance ('if the user wants to apply, point them to applyUrl; the user must apply themselves'), which is useful, but never states the upstream condition for calling this tool — e.g. that a programId must first come from list_support_matches/search_support_programs. That routing hint lives only in the schema, not the description, so usage is implied rather than explicit.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false). The description adds the personal-scope and list-operation context, but does not disclose pagination defaults, ordering, or result behavior beyond what annotations and schema already imply.

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 compact, front-loaded sentence with no filler. Every word contributes to identifying the operation and scope.

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

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

For a simple read-only list tool with two optional pagination parameters and no required inputs, this is adequate: the safety profile is handled by annotations and the purpose is clear. Missing pagination behavior and output shape expectations leave minor but real gaps.

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

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

Schema description coverage is 0%, and the description says nothing about page or limit. The parameter names and integer bounds provide minimal meaning, but the description does not compensate for the coverage gap with pagination context, defaults, or usage hints.

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 ('조회합니다' = retrieves) and identifies the exact resource ('내 포인트 충전 신청 내역' = my point charge request history). This clearly separates it from singular get_charge_request and from request/cancel charge request siblings.

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

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

The 'my' scoping implies this is for viewing the caller's own charge request history, and the list semantics are clear. However, there is no explicit contrast with get_charge_request for single-item lookup or cancel_charge_request for actions on a request, so when-not-to-use guidance is missing.

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 and destructiveHint=false, so the description does not need to restate safety. It adds useful context by clarifying that this returns 'my' orders and that the status values are restricted to the listed set, but it does not disclose output shape, ordering, or pagination behavior. This is adequate but not rich.

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

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

Two compact sentences with the main action front-loaded and filter details following. Every word contributes useful information without redundancy or filler.

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

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

For a simple read-only list tool, the description plus schema is largely complete: it states the resource, the filtering options with allowed values, and pagination parameters are documented in the schema. There is no output schema, so a bit more detail on return structure would strengthen it, but nothing essential is missing for making the call.

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 baseline is 3. The description adds clear value beyond the schema by listing the exact status values and their Korean meanings (paid, in_progress, completed, refunded, stopped), which the schema's generic '상태 필터' does not provide.

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: '내 주문 내역을 조회합니다' (retrieves my order history), and states the status filter capability. It clearly communicates what the tool does, though it does not explicitly differentiate itself from the sibling 'get_my_order' for singular lookups.

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

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

No guidance is given about when to use this tool versus alternatives such as 'get_my_order', 'list_charge_requests', or 'create_order'. The description only shows that filtering by status is possible, providing no exclusions or alternative routing.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: only in-progress bids are returned, qualification-failing announcements are excluded, and the score scale is explained (60 = unrestricted, 60–100 = more verified attributes). It still omits return-field/pagination behavior, but the added filtering and scoring semantics are substantial.

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 first clause, followed by score semantics and use-case examples. The scoring explanation is slightly long but each part conveys non-obvious information (exclusion rule, score band meaning).

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

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

For a read-only list tool with no output schema, the description covers the key behavioral facts an agent needs: what subset is returned (in-progress only, qualification-filtered), how results are ordered, and what the score means. Return field structure is not described, which is the only notable gap.

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

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

Schema description coverage is 80%, so the schema already documents sort, limit, minScore and profileId; only 'page' is undocumented. The description's score explanation gives indirect meaning to minScore/sort=score, but adds no direct parameter syntax or defaults beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('나라장터 입찰공고 추천 목록을 조회합니다') and scopes it with '내 사업 프로필에 맞는', which separates it from the generic search_procurement_bids sibling. The differentiation is implied rather than named explicitly, so it falls short of a 5.

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

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

Provides concrete example user questions ('우리 회사가 들어갈 수 있는 입찰 뭐 있어?', '나라장터 용역 공고 찾아줘') that give clear routing context. However, it never names the alternative tool (search_procurement_bids) or states when NOT to use this one, so it stops short of explicit when/when-not guidance.

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

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

Annotations already flag readOnly, idempotent, and non-destructive behavior. The description adds useful behavioral context: no authentication is needed, and the aiOrderable flag determines whether a product can be ordered via payment link. This goes beyond the structured annotations without contradicting them.

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

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

Three compact sentences front-load the primary purpose, then add the key exception handling and auth note. Every sentence earns its place; no filler or redundant restatement of the tool name.

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

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

For a no-parameter, read-only list tool without an output schema, the description is complete: it enumerates the return fields, explains the aiOrderable special case, and provides the escalation path. Nothing an agent needs to call it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing to explain beyond the schema. The description instead clarifies what the returned product list contains, which is the appropriate compensation given the empty params object.

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 (조회, 'retrieve') and a concrete resource: the orderable marketing product list, enumerating the fields returned (ID, name, category, unit price, min/max quantity). This clearly sets it apart from the singular sibling get_product and from order-flow tools like create_checkout.

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 when the tool is usable (no login/key required) and gives an explicit routing rule: products with aiOrderable=false should go through the website or submit_inquiry. It does not explicitly contrast list_products with get_product for single-item lookups, so the when-not-to-use guidance is slightly incomplete.

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

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

Beyond the readOnly/destructive/no-openWorld annotations, it discloses substantial behavior: score interpretation (60 = open to all, 60-100 rises with verified eligibility), that ineligible programs are pre-filtered out, and that isContest=true items are competitions that must be disclosed as such. These are non-obvious traits an agent could not infer from structured fields.

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?

Dense but front-loaded: purpose first, then score semantics, filtering note, profileId guidance, and the contest caveat. Each sentence adds an actionable detail, though the contest-disclosure instruction is slightly tangential to tool invocation.

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

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

For a read-only list tool with full schema coverage and no output schema, the description covers filtering semantics, sort behavior, and key returned attributes (score, isContest, programTypeLabel). It does not describe pagination/return shape explicitly, but that is minor given the schema and annotations.

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: it explains what the score values mean (contextualizing minScore/sort=score) and clarifies profileId's default (representative business when omitted). That goes beyond the schema's terse field notes.

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

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

States a specific verb+resource (retrieve a list of government support-program recommendations matching the business profile) with scope (open announcements only, sorted by match score). This clearly separates it from the sibling list_procurement_matches and search_support_programs.

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

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

Gives a concrete usage trigger ('우리 회사가 받을 수 있는 지원금 뭐 있어?') and explains profileId behavior for multi-business users (omitted = representative). It does not name sibling alternatives or when-not-to-use, 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?

Annotations declare readOnlyHint=true and destructiveHint=false, but the description adds important context: it explicitly states '돈이 나가지 않는 안전한 호출입니다' (safe call that doesn't take money) and that the quoteToken is valid for 15 minutes. This goes beyond the annotations by explaining the safety and time-sensitivity. The description also reveals the return includes total, point balance, and shortage, which is valuable 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 concise, front-loaded with the purpose '1단계 견적을 요청합니다', and then lists key return values and safety. Every sentence earns its place: the step hierarchy, the return details, the validity period, and the safety reassurance. No fluff.

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

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

For a quote tool with an output schema absent, the description explains the return values sufficiently (total, point balance, shortage, quoteToken). It covers the safety and validity period. However, it doesn't explain how the quoteToken should be used in subsequent steps (e.g., create_order), which could be inferred from sibling names but is not explicit. Also, formData and templateOption parameters are not elaborated in the description, but they are covered in the schema. Overall, complete enough given the annotations.

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 all parameters are documented in the schema. The description does not add much beyond the schema, except that 'quantity' combined with 'productId' yields total amount (unit price × quantity), which is a semantic relationship not explicitly in the schema. This slight addition justifies a 3 instead of a lower score, but baseline 3 is appropriate given full 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 clearly states the verb '견적을 요청합니다' (request quote) and the resource (order). It distinguishes this as step 1 of the order process, differentiating it from create_order and other order-related siblings. The scope is specific: it returns total, point balance, shortage, and a quoteToken.

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 this is the first step before creating an order (create_order), suggesting when to use it. It does not explicitly mention when not to use it or compare to siblings like get_product, but the step indicator '1단계' gives clear contextual guidance. Lacks explicit 'when not to use' but sufficient for most agents.

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, destructiveHint=false), the description discloses that the actual bank transfer is the user's responsibilityaine and that points auto-charge only when depositor name and amount match. It also tells the agent to surface the transfer details to the user. These are meaningful behavioral details that help the agent set expectations correctly.

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 tight sentences in Korean. The first sentence states the core action, and the second provides the essential user-facing operational guidance. There is no fluff, repetition, or unnecessary background; every word 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?

Given the lack of an output schema, the description compensates by telling the agent what to do with the transfer field in the response and what success behavior to expect. It covers the key operational flow for the agent. It does not detail error cases or other potential response fields, but for a straightforward request tool this is acceptable and near-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 input schema already provides 100% descriptive coverage for all six parameters, including the requirement that depositorName match the actual transfer name. The description reinforces the relationship between amount/depositorName and automatic charging, but it adds little beyond the schema's existing explanations. Therefore the baseline 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 specific verb ('신청합니다' = apply/request) and a unique resource (포인트 충전 = point charge), which immediately distinguishes this tool from siblings like cancel_charge_request, get_charge_request, and list_charge_requests. It also adds concrete post-call details about the transfer object, making the purpose unmistakable.

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 when to use the tool: when a user wants to request a point charge via bank transfer, and it explains the auto-charge condition. However, it never explicitly contrasts this with alternatives such as create_checkout or create_order, nor does it state when not to use the tool. The usage context is clear but only implied, not directly prescribed.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about the returned fields (placeId, business name, address), but does not disclose additional behavioral details such as whether results are a list or how ambiguous matches are handled. No contradiction with annotations.

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

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

The description is two short sentences with no filler. It front-loads the verb and resource, then immediately explains the purpose and expected output. Every sentence contributes useful 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 single-parameter, read-only search tool, the description covers what it does, why it is used, and the fields returned. Since there is no output schema, this is mostly sufficient, though it could be slightly more complete by clarifying whether the tool returns a single result or a list of candidates to choose from.

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

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

The schema already provides 100% coverage of the single keyword parameter, including an example. The description reinforces that the keyword should be a business name or search term and ties it to the use case of identifying the user's store, but it does not add meaningful new parameter semantics 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 states a specific action and resource: searching Naver Places by business name or keyword, with a clear intended outcome of identifying the user's store and retrieving placeId, store name, and address. This distinguishes it from the sibling tools, which are checkout, product, and auth operations.

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 frames when to use the tool: when the task is to locate the user's store and obtain place identifiers from Naver Places. It does not name alternatives or exclusions, but the sibling tools are clearly different in purpose, so the context is sufficient.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description does add genuine value: the data freshness (매일 자동 수집) and the conditional matchScore enrichment when a profile exists. However, it omits pagination behavior, result limits, and ordering, so it does not go much beyond basic 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?

Two tight sentences with the core action front-loaded and no filler. It could be marginally more efficient but earns its length by conveying the data source and matchScore 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 an 8-parameter, no-required-args search tool with no output schema, the description covers purpose, filters, and the matchScore side effect. It leaves pagination/limit semantics and the empty-query default behavior unstated, which matters for an agent composing a call.

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 63%, with the enum and region/search descriptions doing most of the documentation work. The description maps its four filter keywords to search/category/region/tag and explains that profileId drives matchScore, but adds nothing about page, limit, or status. Baseline 3 is warranted given partial 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?

States a specific verb (검색) and resource (나라장터 입찰공고) with the filter dimensions (키워드·업무구분·지역·태그), and notes the data provenance (조달청 오픈API 일일 수집 DB). This is clearly a search tool, distinguishable from get_procurement_bid, though it never contrasts itself with the sibling list_procurement_matches.

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

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

No when-to-use guidance, prerequisites, or named alternatives. An agent cannot tell from the text when to prefer this over list_procurement_matches or get_procurement_bid. The only implicit cue is the verb 검색.

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

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

Annotations already declare readOnlyHint=true / destructiveHint=false, so safety is covered. The description adds genuine context beyond that: results carry matchScore when a profile exists, and isContest=true items are competitions that must be disclosed as such when introduced.

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 the core purpose and source before the profile and contest nuances. The final instruction about announcing contests is slightly tangential but still operationally relevant, so little is wasted.

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

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

There is no output schema, so the description should carry more of the return-shape burden; it only mentions matchScore appearing in results and says nothing about result fields or pagination output. For a 7-parameter, zero-required search tool the coverage is adequate but leaves real gaps.

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

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

Schema description coverage is 86%, so the schema already documents page, limit, region, search, status, category and profileId in detail. The description only adds that a profile is what triggers matchScore, which is marginal over the schema's own note about profileId.

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 ('정부지원사업 공고를 키워드·카테고리로 검색') plus the data provenance (daily K-Startup collection), so an agent knows exactly what is being searched. It does not name the neighbouring single-lookup (get_support_program) or match-list (list_support_matches) tools, so differentiation relies on inference.

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 gives the triggering situations: '특정 사업명을 찾거나 전체를 둘러볼 때 사용하세요' (looking up a named program or browsing everything). It provides clear usage context but no when-not conditions or named alternatives for the sibling search/match tools.

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

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

Annotations already mark the tool as non-read-only, non-idempotent, and non-destructive. The description adds useful behavioral context by disclosing the SMS side effect and requiring explicit user consent before calling. It does not mention rate limits or code expiration, but those are not essential for basic correct invocation.

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 front-loaded with the core action, followed by clear usage conditions, next steps, and an alternative. Every sentence carries useful information with no repetition or filler.

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

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

For a simple one-parameter tool with no output schema, the description is complete: it explains the action, when to call it, what to do after the SMS is sent, and how it relates to a sibling tool. An agent has enough context to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents the phone parameter with format hints and length constraints. The description adds no additional parameter semantics beyond what the schema provides, landing at 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?

The description states a specific action and resource: sending a verification code SMS to the user's phone as signup step 1. It also distinguishes itself from sibling tools by naming the follow-up (signup) and the alternative payment path (create_checkout).

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 an explicit trigger condition: only call when the user clearly says they want to sign up. It also provides routing guidance by noting create_checkout can be used without signup, and tells the agent to ask the user for the code and pass it to signup.

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 are all false (readOnlyHint, destructiveHint, etc.), so the description carries the behavioral burden. It discloses that account creation is a write operation, that consent flags require genuine human confirmation, and that linking a checkoutToken attaches an existing order to the new account – a side effect beyond the schema. It doesn't cover error cases, but key behaviors are transparent.

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 sentences, each carrying a distinct piece of information: purpose, credential sourcing, consent requirement with URLs, and conditional checkoutToken linking. The purpose is front-loaded in the first sentence, and there is no verbosity 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 12-parameter, 7-required signup with a prior step and optional payment linking, the description covers the essential flow: verify code, collect real user data, require explicit consent, and link a previous checkout if present. It doesn't explicitly state that send_signup_code must be called first (though the schema's phone description pins this) or describe the return value, but these gaps are minor given annotations and schema coverage.

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. The description adds meaningful value by insisting that loginId/password/name be user-provided ('임의로 짓지 마세요') and by supplying the exact terms and privacy URLs to show the user, which the schema lacks. These are actionable semantics beyond the schema's 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 opens with '[회원가입 2단계]' and states '인증번호를 확인하고 계정을 만듭니다' – a specific action (verify code and create account) with a clear resource (account). This clearly distinguishes it from sibling send_signup_code and other tools in the list.

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 conditional usage instructions: collect credentials directly from the user, only set consent flags after showing the linked terms and receiving explicit confirmation, and include checkoutToken only when a payment link was previously created. It doesn't explicitly name alternatives or when-not-to-use cases, but the step-2 label and schema reference to send_signup_code imply the sequencing.

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 only provide hints (readOnlyHint=false, destructiveHint=false), so the description adds meaningful behavioral context: a staff member replies by email within one business day, and name/email must be obtained directly from the user and never fabricated. This is valuable beyond the structured fields.

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 dense sentences cover purpose, response SLA, when-to-use conditions, and a critical data-integrity rule. No filler or redundant repetition of schema fields.

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 10-parameter tool with no output schema, the description covers core invocation needs: purpose, timing, alternatives, and required user data provenance. It could add what the tool call returns to the agent, but the essential guidance for correct invocation is present.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra semantic weight by emphasizing that contactName and contactEmail must be explicitly confirmed from the user and must not be invented, reinforcing the schema's '사용자에게 확인' notes.

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

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

The description opens with a clear verb and resource: '상담·견적 문의를 접수합니다' (receives consultation/quote inquiries). It further distinguishes when to use this tool from orderable-product flows via 'aiOrderable=false 인 상품', making its role unambiguous.

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

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

The description explicitly states when to use this tool: for aiOrderable=false products, when the catalog lacks the requested item, or when the user wants to talk to a human. It does not name alternative sibling tools explicitly or state when-not-to-use conditions, but the usage context is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful context beyond that: it returns newly added server features without reconnecting, and explains that missing tools are accounted for via unavailableGroups with a reason field — useful behavioral detail for an introspection 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?

Three sentences in Korean, each earning its place: the return value, the ideal invocation timing, and the unavailableGroups detail. It is front-loaded with the core purpose and wastes no words on restating the name or title.

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 introspection tool with no output schema, the description is complete: it explains what is returned, when to call it, and how to interpret missing tools. Annotations cover the safety profile, so nothing an agent needs to invoke it correctly is missing.

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

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

The tool has 0 parameters, so the baseline is 4. The description adds value by explaining what the return payload contains (identity, permissions, tool list, unavailableGroups.reason), compensating for the absence of an output 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 — it returns the connection's identity, permissions, and the full list of usable tools. It differentiates from all siblings (checkout, product, signup, inquiry tools) by explicitly addressing 'what can I do?' / 'what are my permissions?' questions, so an agent can tell this apart without opening any other definition.

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 explicit when-to-use guidance: call once before starting work involving company data, and use it for capability/permission questions. It doesn't name exclusions or alternatives, but the sibling tools are all distinct operations (checkout, product lookup, signup), so the usage context is clear without needing explicit negative guidance.

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