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

No annotations exist, so the description carries the full burden. It discloses that no confirmation is required, which is useful, but it does not say whether cancellation is irrevocable, whether partial fills are handled, or what constraints exist (e.g., only for own orders). For a mutating tool, this is a significant 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 efficient sentence front-loaded with the action. No wasted words, but it is so brief that it under-serves the agent on behavioral 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?

Output schema covers return values, but the tool is a mutating operation with no annotations, no parameter descriptions, and no usage context. Missing details like prerequisites, error conditions, and irreversibility make the description incomplete for safe autonomous invocation.

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

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

Schema description coverage is 0% and the description does not explain account_seq or order_id. The agent must guess their meaning from names alone. The description should compensate for the lack of schema documentation but does not.

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 (Cancel) and resource (a pending live order), and differentiates itself from place_order and modify_order by scope. The phrase 'pending live order' makes the target 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 implies when to use the tool (for pending live orders) but provides no explicit when-not-to-use conditions or alternatives. It doesn't mention that completed or partially filled orders may require a different approach, nor does it reference sibling 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?

With no annotations provided, the description carries the full disclosure burden. The phrase 'without exposing it' adds a meaningful safety trait — the agent knows the key will not be leaked. However, it does not disclose what happens when the key is missing (error, boolean flag, log message), which is relevant for a health-check 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?

A single front-loaded sentence with zero waste. Every word contributes: the action, the resource, and the safety guarantee are all packed efficiently.

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, zero-parameter check with an output schema present, the description covers the essential purpose and a key safety constraint. The only notable omission is guidance on when to run this check relative to sibling tools, which does not heavily degrade completeness given the tool's trivial complexity.

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 there is nothing for the description to elaborate beyond the schema. The baseline of 4 for parameterless tools applies; the description correctly avoids inventing parameter detail.

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 ('Check whether the DART API key was loaded'), which clearly identifies the tool's purpose as a configuration/readiness verification. It is distinguishable from siblings like dart_test_connection since it targets key loading rather than connectivity, though it does not explicitly name the 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?

There is no guidance about when to use this check versus the sibling dart_test_connection or other test utilities. The intended invocation context (e.g., before financial-data calls, during setup) is left entirely to the agent to infer.

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 behavioral disclosure burden. It explicitly promises not to expose the credential values, which is a meaningful safety property. It does not detail what happens when credentials are missing, but the presence of an output schema partially covers the result contract.

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 concise sentence that front-loads the action and object while adding the important non-exposure guarantee. There is no 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 zero-parameter diagnostic tool, the description fully conveys what is checked and the key safety behavior. The output schema can carry the return-format details, and the sibling list provides enough surrounding context.

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?

This tool has zero parameters, so there is no parameter documentation burden on the description. The description identifies the exact credentials being checked, which is sufficient given the empty input 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 ('Check') with a clear resource ('TOSS_CLIENT_ID / TOSS_CLIENT_SECRET') and states the key behavioral scope ('were loaded'). It also distinguishes itself from network/connection tests by noting it checks environment loading, not connectivity.

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 intended use case is clearly implied: verify that TOSS credentials are present without exposing them, likely before attempting API operations. It does not explicitly name alternatives like toss_test_connection or check_dart_api_key, but the context makes the selection reasonably 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?

No annotations are provided, so the description bears the burden of behavioral disclosure. It communicates a read-only health-check behavior and a return message, which implies no destructive side effects, but it does not clarify whether the tool performs backend connectivity checks or simply echoes a message back.

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 with no filler. It is front-loaded and easy to parse, though a bit more specificity about the message parameter would make it more useful.

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 health-check tool with an output schema, the description is minimally adequate. However, it lacks explicit parameter semantics and sibling differentiation, leaving some ambiguity for an agent deciding whether this is the right test_connection 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 0%, so the description must compensate, but it only says 'return a message.' It does not explicitly state that the required `message` string is echoed back, how it is used, or what format/constraints apply.

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 ('return a message') and a clear purpose ('verify that the MCP server is working'). It is differentiated from the telegram and finance test_connection siblings mainly by the 'dart' name prefix, though it does not explicitly call out that distinction.

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

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

There is no guidance about when to use this tool versus sibling test_connection tools or the data-oriented tools. No conditions, exclusions, or alternatives are mentioned, so the agent must rely on the name and generic purpose only.

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. It discloses the side effect of writing to local disk, the default destination folder, path traversal restrictions, and filename sanitization/de-duplication. These are material behaviors an agent needs to anticipate before invoking the 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 focused sentences: the main action and return value come first, followed by destination behavior and filename handling. There is no 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?

The description covers the operation, side effects, path security, and filename behavior, which is strong for a 3-parameter tool with an output schema. It does not describe error cases such as missing attachments or invalid message IDs, but those are not essential for correct tool selection and 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?

With 0% schema description coverage, the description compensates by explaining dest_dir's role and security constraints. It also relates chat and message_id to 'one message', though it does not explicitly describe chat's format or how to obtain message_id. The parameter names and context largely resolve this.

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 names the action (Download), the object (file attached to one message), and the result (path on local disk). This clearly distinguishes it from sibling tools like search_files or get_messages, which locate or retrieve data but do not download attachments.

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 makes the intended use case clear: download a message attachment to a local path. However, it does not explicitly contrast with alternatives or state when not to use this tool, so routing guidance is mostly 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?

No annotations are provided, so the description carries the full burden. 'Check credentials/connectivity' communicates a diagnostic, likely non-mutating operation, but it does not disclose whether the call makes external network requests, how failures are surfaced, or whether any credentials are exposed. It is adequate but minimal.

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 names all three services and the operation. It contains no filler and front-loads the essential 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?

With no input parameters and an output schema available, the description's main job is to identify what connectivity is being tested. It fully does so by naming DART, Toss, and Telegram. Nothing necessary for calling this tool 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 zero parameters, so the description need not explain parameter meaning. The baseline of 4 applies because there is nothing to document and the description correctly focuses on the tool's scope.

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 ('Check') and identifies the exact resources (DART, Toss, Telegram credentials/connectivity) in one call. This clearly distinguishes it from the per-service siblings like dart_test_connection, toss_test_connection, and telegram_test_connection.

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

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

The phrase 'in one call' implies this tool is the aggregate option when checking all three services at once, but the description does not explicitly say when to choose it over the individual test_connection tools. Usage guidance is present by implication rather than explicit direction.

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 burden of behavioral disclosure. It does disclose that the tool returns accountSeq and that it lists accounts, which implies a read-only operation. However, it does not mention authorization requirements, account scope (e.g., real vs. paper accounts), or any other behavioral constraints. This is adequate but not fully 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?

The description is extremely concise: two sentences, no filler, with the key output value (accountSeq) front-loaded and the dependent tools named. Every sentence contributes essential 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?

Given that the tool has no parameters and an output schema exists, the description provides all the context needed for an agent to understand what the tool returns and how it fits into the broader workflow. It also names the dependent tools, making the context complete without being verbose.

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 there is no parameter-level information needed. The schema coverage is effectively 100% because the properties object is empty. The description adds useful return-value context (accountSeq) even though there are no parameters to explain.

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

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

The description clearly states the tool's function: listing Toss Securities accounts. It also distinguishes the tool by explaining that it returns accountSeq, which is required by other account tools, making its role in the tool family explicit.

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

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

The description explicitly identifies this as a prerequisite for other account tools (get_holdings, get_buying_power, etc.), which tells the agent when this tool should be used first. It does not explicitly state when not to use it, but the context is clear enough for an agent to infer the correct usage.

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

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

No annotations are provided, so the description carries the full burden. It explicitly marks the operation as 'read-only,' which is the key behavioral trait for a getter tool. It does not discuss rate limits or auth, but for a simple read-only balance lookup this is acceptable.

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, front-loaded with the purpose, and uses a short Args list for parameter details. There is 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 two-parameter read-only getter, the description covers purpose, parameter provenance, and allowed values. The tool has an output schema, so return-value documentation is not strictly required. Minor gaps like error behavior or permission requirements are not critical here.

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

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

Schema coverage is 0%, but the description fully compensates: it explains that account_seq is the numeric accountSeq returned by get_accounts() and that currency must be 'KRW' or 'USD.' This adds meaning beyond the raw schema and directly supports correct invocation.

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

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

The description states a specific action and resource: 'Get cash buying power for one account.' This clearly distinguishes it from sibling tools like get_accounts, get_holdings, or get_sellable_quantity. The Korean label reinforces the purpose without ambiguity.

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

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

The description gives clear context: it operates on one account and explains that account_seq should be the numeric accountSeq from get_accounts(). It does not explicitly name alternatives or exclusions, but the prerequisite relationship with get_accounts() provides enough guidance for typical use.

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. It discloses meaningful traits beyond the schema: only one symbol per call, count limits (1-200), default to most recent candles, pagination via 'nextBefore' cursor, and adjustment behavior for splits/dividends. It omits error/rate-limit behavior, but the core operation is well-specified.

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 tightly structured docstring: one purpose sentence followed by an Args list. Each parameter gets exactly the needed detail with no filler, and the purpose is front-loaded. The parenthetical Korean translation adds negligible noise but does not hurt.

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 output schema covers return values, the description is nearly complete: all parameters, valid values, pagination, and single-symbol constraint are present. The only notable gap is lack of explicit routing guidance against sibling market-data tools, which is a minor omission for a well-scoped getter.

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

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

Schema description coverage is 0%, so the description must compensate. It explains all five parameters with concrete examples (e.g., '005930' vs 'AAPL'), valid interval values, count range, pagination semantics, and the adjusted flag. This fully compensates for the empty schema 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 'Get OHLCV candle-chart data for a single symbol', a specific verb+resource that clearly differentiates it from siblings like get_recent_trades or get_current_price. The single-symbol constraint and parameter scope further pin down its exact role.

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 context is clear: this is for single-symbol OHLCV data with pagination. However, it never explicitly states when to choose this over sibling market-data tools or when not to use it, so usage guidance remains implied rather than stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that title resolution is best-effort, that ID resolution can fail on a fresh session, and that warming the cache via list_dialogs fixes it. This adds meaningful operational context beyond the 'get' intent, though it does not mention rate limits or permission requirements.

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: the first sentence states precisely what the tool returns, and the second sentence covers input forms and a failure-handling workflow. Every sentence earns its place, with no filler or 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?

The tool has only one parameter, and that parameter is thoroughly explained. An output schema exists, so the return values need not be re-described. The description also covers the main failure mode and its remedy, making this complete for an agent to select and invoke correctly.

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

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

The input schema only says 'chat' can be a string or integer with no semantic detail. The description fully compensates by explaining the accepted formats (@username, numeric/marked ID from list_dialogs, or best-effort title), so an agent knows exactly what values to pass and how to resolve ambiguity.

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 ('Get') and a resource ('chat info') and enumerates the exact fields returned: title, description/about, member count, type, and username. This clearly distinguishes the tool from sibling tools like list_dialogs, which lists chats, and get_messages, which retrieves messages.

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 concrete input-resolution guidance: chat may be a @username, a numeric/marked ID from list_dialogs, or a best-effort chat title. It also gives a clear fallback workflow—call list_dialogs first to warm the entity cache and retry—which is actionable usage guidance, though it does not explicitly contrast this tool with alternatives.

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. It explicitly marks the operation as read-only, which is the most important behavioral trait for safe agent use. It also notes that the account identifier originates from get_accounts(), adding useful 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 compact and front-loaded: purpose first, read-only note second, then parameter guidance. Every sentence earns its place with no filler or redundant restating 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 single-parameter read-only tool with an output schema, the description covers the essential invocation context: what the tool does, that it is safe, and where to get the required parameter. It doesn't mention edge cases like invalid account_seq, but the output schema and simplicity of the tool make this a minor 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?

The schema provides no description coverage for account_seq, but the description compensates by explaining that it is the numeric accountSeq returned by get_accounts(). This tells the agent both the type and source of the parameter, which is valuable beyond the raw 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 clearly states that the tool retrieves brokerage commission rates by market, using the specific verb 'Get' and a concrete resource. This distinguishes it from related account and trading tools such as get_accounts, get_holdings, and get_buying_power.

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 prerequisite: account_seq must come from get_accounts(). It does not explicitly name alternatives or state when not to use the tool, but the context is clear enough for an agent to know this is the commission-rate lookup 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 provided, the description carries the burden of disclosing behavior. It does indicate that this is a retrieval operation from an external source (Open DART) and implies read-only behavior, which is accurate. However, it does not mention authentication requirements, API key prerequisites, rate limits, or failure modes, which are relevant for calling an external API.

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 and well-structured. The main purpose is stated in the first sentence, followed by a clearly labeled Args section with the parameter explanation. There is no redundant content, and the example adds tangible value without bloat.

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 with an output schema, the core essentials are present: what it does and what the input is. However, it lacks contextual signals such as prerequisites (e.g., DART API key), how to obtain the corp_code, and relationship to sibling tools like get_company_profile_by_query. This is a clear gap that an agent would need to resolve elsewhere.

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?

Even though schema description coverage is 0%, the description fully compensates for the single parameter. It specifies that corp_code must be an eight-digit DART corporation code and provides a concrete example (Samsung Electronics is 00126380), giving an agent precise format and context to construct a valid call.

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: 'Get official company information from Open DART.' It clearly indicates that the input is an eight-digit corporation code, which distinguishes it from the sibling get_company_profile_by_query. However, it does not explicitly name or contrast itself with that sibling, so it falls just short of full differentiation.

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

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

There is no guidance about when to use this tool versus alternatives. The description only explains the parameter and gives an example; it does not mention that a user might need to search for a company code first or when to prefer get_company_profile_by_query. The agent is left to infer usage context from the tool name and sibling list.

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 present, so the description must carry behavioral disclosure. 'Find... and return' conveys the main read-style behavior, but it does not mention authentication requirements, no-match behavior, or invalid query handling.

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?

One focused sentence states the purpose, followed by a compact Args block. There is no filler, redundancy, or unnecessary restatement of schema 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 one-parameter lookup with an output schema present, the description covers the main calling requirement. It would be slightly more complete with a pointer to search_company for partial-name lookups.

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 only declares a generic string 'query,' while the description fully specifies accepted formats: exact company name, six-digit stock code, or eight-digit DART code. This adds essential meaning that the schema alone completely lacks.

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 'Find a listed company and return its DART company profile,' giving a clear verb, resource, and output. It is clearly a lookup tool, though it does not explicitly contrast with the sibling search_company.

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 query spec ('Exact company name, six-digit stock code, or eight-digit DART corporation code') implies use when the caller already has an exact identifier. It does not mention alternatives or instruct what to do with partial or unknown names, so the guidance remains 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 of behavioral disclosure. It does state key behaviors: returns current last-traded price, supports batching up to 200 symbols, and requires symbols without market prefixes. However, it omits behavioral details like error handling for invalid symbols, whether prices are delayed, or how multiple symbols map to the response.

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 in the first sentence followed by a short Args block. The Korean translation '(현재가 조회)' is somewhat redundant for an English-facing definition but does not introduce confusion. Overall, each part earns its place with no significant 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 read-only tool with an output schema, the description is largely complete: it states the purpose, the parameter format, limits, and examples. It does not explain output structure or explicitly route to alternatives, but the output schema covers return values and the tool complexity is low. A brief sibling reference would have made 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 only defines 'symbols' as a required string with no description, so schema description coverage is 0%. The description fully compensates by explaining exactly how to format the parameter: comma-separated, up to 200, no market prefix, with concrete examples like '005930,000660' and 'AAPL,MSFT'. This is precisely the information an agent needs to invoke the tool correctly.

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 starts with a specific verb 'Get', clearly identifies the resource as 'current (last-traded) price', and scopes it to 'one or more symbols'. This distinguishes it from siblings like get_orderbook, get_candles, and get_recent_trades by emphasizing the last-traded price aspect. Concrete KRX and US examples reinforce the resource scope.

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 useful input constraints — comma-separated, up to 200 symbols, no market prefix — but it does not explicitly say when to use this tool versus alternatives such as get_orderbook or get_candles. The usage context is implied by 'current (last-traded) price' rather than explicitly contrasted with sibling 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?

With no annotations, the description carries the burden of explaining behavior, and it does so: it downloads the original filing and strips HTML to produce plain text, implying a read-only retrieval operation. It does not mention potential auth requirements or response size, but the core behavior is transparently disclosed.

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 main purpose is front-loaded in the first sentence, with a clear Args block for the parameter. Minor redundancy like 'or other DART tools' and the generic 'Useful for...' sentence could be trimmed, but the description is still compact and well organized.

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

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

For a single-parameter tool with no output schema, the description explains the input, the operation, and the resulting plain-text output sufficiently well. It could add detail about API-key expectations or very large responses, but the essential context for correct selection and 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?

The schema only provides the parameter name and type, but the description adds crucial semantics: rcept_no must be a 14-digit receipt number and is typically the value returned by search_disclosures. This fully equips an agent to provide the correct argument.

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 ('Get'), names a concrete resource ('plain-text content of one DART disclosure document'), and explains the transformation ('strips HTML markup'). This clearly distinguishes it from sibling tools like search_disclosures, which are about finding filings rather than retrieving their content.

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 ties usage to search_disclosures ('any filing found via search_disclosures'), which tells an agent when this tool is appropriate. It does not list exclusions or alternative tools for different needs, but the provided workflow guidance is 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses the data source endpoint, the scope of data (current period and two prior periods), and the specific dividend figures returned. It does not mention API key requirements or rate limits, but for a read-only retrieval tool this 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 well-structured and front-loaded with the tool's purpose, followed by the endpoint context and a clean Args block. Every sentence and argument description adds useful information, including the Korean terms and concrete examples.

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 data retrieval tool with an output schema, the description is complete: it covers purpose, endpoint, period scope, all parameters, allowed report types, and the fields returned. An agent has enough information to select and invoke the tool correctly without opening external documentation.

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

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

The input schema provides only parameter names and types with 0% description coverage, but the description fully compensates by documenting every parameter: corp_code with an example, start_year/end_year formats and examples, and the allowed report_type values including 'all'. This is exemplary parameter-level guidance.

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 and resource: 'Get dividend-related figures' across a range of years, and further identifies the exact Open DART endpoint and the specific figures returned. This clearly distinguishes it from sibling tools about financial statements, shareholder status, and price 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 clearly indicates this tool is for dividend-related data and explains how report_type selects report filings. It does not explicitly state when not to use it or name alternative tools, but the context is strong enough that an agent can infer the appropriate use case.

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 behavioral burden. It discloses the key distinction — historical rate when date_time is supplied versus latest when omitted — which is core to correct invocation. It does not disclose failure behavior for unsupported currencies, whether credentials are required, or the rate basis (mid-market vs bid/ask), making coverage 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?

The description is compact and well-structured: a single-purpose first sentence followed by a clean Args block. Every element earns its place, and the Korean parenthetical is harmless bilingual redundancy rather than filler. The core purpose is front-loaded ahead of parameter details.

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

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

Given the low complexity (three optional parameters, simple string/null types) and the presence of an output schema, the description is not responsible for explaining return values. It thoroughly covers parameters and the core latest-versus-historical behavior. The only minor gaps are explicit base/quote direction semantics and any credential 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 0% and the schema has no enums, yet the description fully documents all three parameters: the allowed KRW/USD values for both currency arguments and the ISO 8601 semantics of date_time. This completely compensates for the schema's lack of descriptions, leaving no parameter ambiguity for the agent.

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 opening line 'Get the exchange rate between two currencies' uses a specific verb and resource, stating exactly what the tool returns. No sibling tool covers currency exchange rates — the closest siblings are stock price and disclosure tools — so the purpose is unambiguous and self-distinguishing.

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 Args block gives clear usage context: passing a date_time retrieves a historical rate while omitting it returns the latest rate, and both currencies are constrained to KRW or USD. This makes the supported scope obvious. However, it names no alternatives or explicit when-not-to-use conditions, so exclusions are absent.

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. It explicitly discloses that the endpoint returns the full filing history, that date filtering and limits are applied client-side, and that large-cap companies may have thousands of filings. It does not mention error behavior, rate limits, or auth prerequisites, but it is unusually transparent for a read-only data retrieval 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 front-loaded with purpose and behavior, then organized into an Args block. Every sentence earns its place: endpoint behavior, default-date rationale, large-data warning, and parameter details are all relevant. 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?

The description is complete enough to invoke the tool correctly: all parameters are defined, defaults are explained, and the output schema covers return values. It lacks an explicit API-key prerequisite and alternative-tool routing, but those are minor relative to the strong invocation guidance provided.

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 provides no descriptions, so the description fully compensates. It explains corp_code with an example, date formats and default behaviors for start_date and end_date, and limit semantics including default, maximum, and ordering behavior. This goes well beyond what the schema alone conveys.

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 resource: executive/major-shareholder stock ownership reports, with a concrete verb and endpoint context. However, it does not explicitly differentiate itself from sibling tools such as get_major_shareholder_status, get_major_shareholder_changes, or get_major_holding_reports, which appear to overlap in subject matter.

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 strong context about what the endpoint covers and when filings occur ('whenever their holdings change'), so usage is implied. It does not state when to prefer this tool over alternates or when not to use it, which is a notable gap given the many similar sibling 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?

With no annotations, the description carries the transparency burden. It discloses that it calls Open DART's key-accounts endpoint and returns core line items for both CFS and OFS statements, and it enumerates report types. It does not discuss API-key prerequisites, rate limits, or error behavior, but for a read-only fetch that is not a critical omission.

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 front-loaded with the core purpose and uses a clean Args block. The Korean translations and endpoint detail add some length, but they are informative for Open DART users; no sentences are 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?

Together with the output schema, the description is complete for an agent to invoke correctly. It covers all 4 arguments, their formats, the default report_type, the data source, and the scope of figures returned. No required calling information is missing.

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

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

Schema coverage is 0%, but the description fully compensates: every parameter is documented with format, allowed values, and examples. The corp_code example ('Samsung Electronics is 00126380'), four-digit year convention, and report_type mapping make the tool callable without external documentation.

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 ('Get') plus resource ('key financial-statement accounts') and a clear scope ('for a company across a range of years'). It also names the exact Open DART key-accounts endpoint and lists the figures returned, which distinguishes it from the sibling get_full_financial_statement.

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

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

The phrase 'key financial-statement accounts' and endpoint choice imply this is for key figures rather than the full statement, and the sibling get_full_financial_statement is an obvious alternative. However, it never explicitly says when to prefer this tool over that sibling or states exclusions, so it stops short of full 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 transparency burden. It does disclose the external Open DART endpoint and that it returns every line item in the balance sheet, income statement, and other statements. It does not mention API-key requirements, network-call implications, error behavior, or potentially large payloads, so transparency is adequate but incomplete.

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 front-loaded with the core purpose and then uses a clean Args section for parameter detail. No sentence is wasted; the length is justified by the absence of parameter documentation in the schema.

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

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

Given that an output schema exists, the description does not need to explain return structure, and its parameter coverage is complete. The only notable gap is the lack of any prerequisite/alternative guidance, such as requiring a valid DART API key or when to choose get_financial_statements instead.

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 fully compensates: it documents all four arguments, including corp_code format and example, year format, report_type choices with Korean labels, and fs_div choices with the default. This is exactly the semantic info an agent needs beyond the raw 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 and object: 'Get the complete financial statement (every line item) for one period.' It further clarifies the scope (single business year/report type) and names the underlying endpoint, making it easy to distinguish from the sibling get_financial_statements.

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 or when-not-to-use guidance is provided, and no alternative sibling (notably get_financial_statements) is named. The 'every line item' phrasing hints at a full-detail use case, but the agent is left to infer the boundary between this tool and related financial-statement 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly marks the operation as read-only, which is useful, but it does not describe pagination, value freshness, or any other behavioral caveats. It is adequate but minimal.

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 short, front-loaded with the main purpose, and includes only the necessary parameter context. The Korean read-only note is redundant but not harmful; overall there is no wasted 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 query with an output schema, the description is nearly complete. It identifies the required input source and scope, though it could better explain how it relates to sibling tools such as get_buying_power or get_accounts.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaningful context by explaining that account_seq is 'the numeric accountSeq returned by get_accounts(),' giving the parameter provenance and expected format beyond the raw 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: 'Get portfolio summary and per-symbol positions for one account.' It also clarifies the read-only nature and distinguishes itself from account-list-level tools by emphasizing 'one account.'

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 instruction that account_seq is 'returned by get_accounts()' implies a clear workflow: call get_accounts first, then get holdings for a chosen account. However, it does not explicitly state when to prefer this over sibling tools like get_buying_power or get_accounts.

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, so description carries the burden. It discloses that DART returns full history without date params and filtering is applied post-fetch, plus the limit's role in capping results. Doesn't cover auth or error cases, but output schema covers return shape.

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

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

Description is front-loaded with purpose, organized with Args, and every sentence carries information: endpoint behavior, defaults, rationale, and usage guidance. 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?

Given output schema exists to document return values, the description covers endpoint mechanics, parameter semantics, defaults, and limit behavior. An agent has everything needed to call it correctly 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?

Schema description coverage is 0%, and the description fully compensates: corp_code format with example, start/end date formats and defaults, limit default/max and why it exists. This is thorough and actionable.

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: 'Get 5%-rule major shareholding disclosure reports', with Korean term and explanation of the 5% rule threshold. Clearly distinguishes from sibling tools like get_major_shareholder_status by emphasizing disclosure reports rather than status.

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

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

Provides clear context for when the tool is relevant (5%-rule filings) and explains default date behavior with rationale (infrequent filings). Does not explicitly name alternative tools or exclusion cases, so not 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 behavioral burden. It explains that the tool lists each date the largest shareholder changed, who the new shareholder was, and why, which goes beyond the minimal 'get changes' phrasing. It could add rate-limit, error, or API-key context, but the core behavior is clearly disclosed.

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

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

The description is well structured with a concise purpose sentence, a useful endpoint-context sentence, and a clearly formatted Args section. The Korean labels and example corp_code are informational rather than redundant, and no sentence 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?

Given the sparse input schema and absent annotations, the description provides enough context for correct invocation: all parameter semantics, an example code, allowed report types, and expected output content. Since an output schema exists, the lack of explicit return-format documentation is acceptable.

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%, but the description compensates fully by documenting all four arguments: corp_code with a concrete example, start_year and end_year with format guidance, and report_type with every allowed value and its Korean equivalent. This adds substantial value over the bare parameter titles.

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: 'Get changes in the largest shareholder ... across years.' It clearly distinguishes this from the sibling get_major_shareholder_status by emphasizing the historical change event list rather than a current status snapshot.

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 context is implied through the phrase 'across years' and the endpoint's purpose of listing shareholder change events, but the description never explicitly says when to choose this over the related get_major_shareholder_status or other shareholder tools. There are no explicit exclusions or alternative routing instructions.

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 full disclosure burden and does well by naming the external API, the endpoint, and the returned fields (shareholder name, relationship, ownership at start/end). It does not mention authentication or rate-limit prerequisites, but for a read-only status fetch the disclosed behavior is solid.

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 front-loaded with the core purpose and API source, then flows into a cleanly formatted Args section. Every sentence earns its place, and the Korean terminology is included without making the text bloated.

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

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

The description covers all four parameters, their allowed values, and the nature of the returned data, while the presence of an output schema reduces the need to document return values in prose. It falls short only by not mentioning API-key/connection prerequisites or explicitly contrasting with sibling shareholder tools.

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

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

Schema coverage is 0%, but the description fully compensates by defining corp_code with a concrete example, explaining the four-digit year format, and enumerating all valid report_type values with their Korean meanings. This adds substantial meaning beyond the bare input 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 ('Get'), a precise resource ('major/largest-shareholder ownership status'), and a scope ('across years'). It also identifies the Open DART endpoint and the exact data elements returned, making it clearly distinguishable from sibling tools like get_major_shareholder_changes and get_minority_shareholder_status.

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

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

The description provides clear context for what the tool fetches and supports report-type selection, but it never explicitly names alternatives or states when to prefer this tool over the closely related shareholder tools. The usage guidance is therefore implied rather than explicitly differentiated.

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 transparency burden. It discloses the return focus (pre/regular/after-market session times), the market scope, and the date behavior. It does not mention timezone or holiday edge cases, but for a read-only lookup the core behavior is clearly stated.

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 opening sentence is front-loaded and specific, and the Args block is concise. The Korean parenthetical is slightly redundant but not harmful; overall the description is appropriately sized and well structured.

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 two optional parameters and an output schema present, the description covers what an agent needs to invoke the tool correctly: the meaning of each parameter and the default behavior. It leaves minor gaps around timezone and holiday handling, but these do not block correct use for typical queries.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It clearly defines market as 'KR' or 'US' and date as an optional YYYY-MM-DD value to center the lookup, with 'omit for today' behavior. This fully compensates for the bare 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: 'Get market session times (pre/regular/after-market) around a given date.' This clearly distinguishes the tool from sibling market-data tools like get_current_price or get_exchange_rate, which address different purposes.

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 practical invocation guidance: choose 'KR' or 'US', and omit the date for today. However, it does not explicitly explain when to prefer this tool over related market-data siblings or when not to use it, so usage is implied rather than explicitly routed.

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 transparency burden and discloses meaningful behaviors: default 7-day window, UTC assumption for timezone-less dates, newest-first ordering, strict offset_id semantics, and an up-to-200 cap. It does not explain offset_id's default-0 sentinel behavior or limit's default, but the disclosed behavior goes well beyond a bare read 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?

The core behavior is front-loaded in the first sentence, and every subsequent sentence adds concrete parameter or response behavior. The backtick-delimited parameter list is scannable and dense without 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 4-parameter tool with no annotations and no schema property descriptions, the description covers the non-obvious aspects of chat resolution, date filtering, timezone handling, ordering, and response fields. The only material gap is the limit parameter's default/max relationship, but the input schema shows the default and the description states the cap, so an agent can still make safe calls.

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 compensates with detailed semantics for chat (types, examples, resolution pointer), since_date (ISO format, examples, timezone handling, default), and offset_id (strictly below, paging). It never names the limit parameter, though its meaning is reasonably inferable from the schema title, default value, and the 'up to 200' statement in the first sentence.

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 opening sentence uses a specific verb ('Get'), a resource ('messages'), and a scope ('from one chat') and states the ordering ('newest first'). This clearly separates it from sibling tools like list_dialogs, get_channel_info, and search_messages, even though those alternatives are not named.

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

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

The description gives clear operational context: one chat, recent messages, an optional cutoff, and paging behavior. It explicitly points to get_channel_info for chat resolution notes, which is helpful. However, it does not explicitly state when to prefer this tool over search_messages or other sibling tools, so it stops short of 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 behavioral disclosure burden. It discloses the underlying endpoint (Open DART's 소액주주 현황), the data provided (number of shareholders, share of total shareholders, proportion of shares), and the report types. It does not mention rate limits, auth requirements, or failure modes, but the read-only nature and data semantics are reasonably 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?

The description is well organized: a one-sentence summary up front, a brief note on the underlying source, then a tight Args block. Every sentence adds value, and the structure makes it easy for an agent to quickly locate parameter requirements.

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

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

The description covers all four parameters with formats and examples, describes the endpoint and the semantics of the returned data, and an output schema already exists. There are no significant gaps that would prevent an agent from selecting and invoking this tool correctly.

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

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

The input schema provides only titles and types (0% description coverage), so the description fully compensates by documenting each parameter: an example corp_code, the expected year format, and every report_type value with Korean labels and a default. This is exactly the kind of parameter guidance an agent needs.

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 ('Get'), a specific resource ('minority/small shareholder status (소액주주 현황)'), and the temporal scope ('across years'). It clearly distinguishes from sibling tools like get_major_shareholder_status by focusing on the minority/small shareholder perspective.

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

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

The description clearly implies when to use this tool: whenever minority shareholder status data is needed, and it explains what the tool reports. It does not explicitly name alternatives or state when not to use it, but the sibling list and subject matter make the primary use case 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?

No annotations are provided, so the description carries the burden of behavior disclosure. The verb 'Get' indicates a read-only retrieval, and 'all available details... including execution information' specifies the return scope, but there is no mention of auth requirements, error behavior, or rate limits. No contradiction with annotations, since none exist.

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 concise sentence that front-loads the verb and resource, with no fluff. It efficiently communicates scope and adds the execution-information 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?

The tool is a simple getter with an output schema, so return values are covered elsewhere. However, the description lacks explanation of the required account_seq parameter and doesn't state any conditions like account ownership, making it incomplete for an agent without domain knowledge.

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 does not explain the parameters. It only mentions 'one order', which helps infer order_id's role, but account_seq is left undocumented. The description adds minimal meaning beyond the parameter names.

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 clearly states 'Get all available details for one order', identifying the verb (Get), resource (order details), and scope (single order). The phrase 'including execution information' adds specificity beyond the name and distinguishes it from the plural sibling get_orders.

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 use for a single order by saying 'for one order', but does not explicitly mention alternatives like get_orders or conditions for when to use this tool over others. No when-not-to-use or prerequisite guidance is provided.

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 burden. It correctly implies a read-only operation via 'Get', and adds the single-symbol constraint, but does not disclose any other behavioral traits such as rate limits, data freshness, or authentication requirements. This is acceptable for a simple read tool 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?

The description is compact and front-loaded: the purpose appears in the first sentence, followed by a clearly formatted Args section. The Korean parenthetical is minor and does not detract from the overall efficiency.

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

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

For a single-parameter tool with an output schema, the description is complete. It covers the purpose, the exact parameter format, and the key constraint. Return values are presumably documented in the output schema, so no additional explanation is needed.

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 only lists 'symbol' as a string with no description (0% coverage). The description compensates fully by specifying no market prefix, giving concrete examples ('005930', 'AAPL'), and highlighting the single-symbol limitation. This adds significant meaning 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: 'Get the current bid/ask order book for a single symbol.' This clearly distinguishes the tool from siblings like get_current_price or get_recent_trades, and emphasizes the single-symbol scope.

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

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

The description gives clear context: the tool works for one ticker symbol only, and explicitly warns 'Only one symbol is accepted per call.' It does not mention alternatives or when not to use it, but the scope is well-defined.

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 of behavioral disclosure. It only says the tool lists orders with filters and does not disclose pagination behavior, ordering, response shape, or required account context. Cursor and limit imply pagination, but the description does not explain how they behave.

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 compact, front-loaded sentence that immediately communicates the core operation. However, it sacrifices precision by using shorthand filter names and omitting the required parameter, so it is not fully effective despite being concise.

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 seven parameters, no annotations, and no schema description coverage, the description is too thin to support correct invocation. It does not mention the required account_seq, does not explain pagination through cursor and limit, and leaves date parameter names ambiguous. The output schema somewhat reduces the burden of explaining return values, but the input side is still incomplete.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It names six of seven parameters but uses 'from' and 'to' instead of the actual 'from_date' and 'to_date', and it completely omits the required 'account_seq' parameter. It adds no detail about date formats, filter semantics, or cursor 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?

States a concrete action, 'List orders', with the resource and a set of filters. It is reasonably distinguishable from siblings like get_order by the plural form, though it does not explicitly contrast itself with them. The filter names 'from' and 'to' are slightly ambiguous because the schema uses 'from_date' and 'to_date'.

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 wording 'List orders using...' implies it is the listing tool for orders rather than a single-order fetcher like get_order, but it never explicitly states when to prefer this tool or when to use an alternative. No exclusions or prerequisites are provided, so usage context is only 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?

With no annotations, the description carries the safety/behavior burden. The verb 'Get' and the explicit 'today's upper/lower price limits' signal a read-only, time-scoped query, and the no-market-prefix rule is a useful constraint. It does not cover invalid-symbol or market-hours behavior, but these are minor for such a simple 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?

Two compact sections: a one-line functional summary with a helpful Korean gloss, followed by a short Args note. No filler, and the key scoping detail is front-loaded.

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

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

For a single-parameter read tool with an output schema, this is nearly complete: it states what is returned, for which symbol format, and for which day. It could add an explicit market/exchange note, but the example and Korean term make the intended domain clear.

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

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

Schema coverage is 0%, so the description is the only place the agent learns what 'symbol' means. It provides the type ('ticker symbol'), the constraint ('no market prefix'), and a concrete example ('005930'), which is exactly the detail needed to call the tool correctly.

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 (Get), a precise resource (today's upper/lower price limits), and a scope (single symbol). This clearly distinguishes it from sibling tools like get_current_price or get_candles, and the Korean equivalent removes ambiguity about what is being queried.

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

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

The description gives clear context: use it when you need today's price limits for a single symbol, and it explicitly warns the symbol must not include a market prefix. It does not name alternatives or exclusions, 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 provided, the description carries the behavioral disclosure burden. It exposes the single-symbol limitation and count bounds, but does not mention ordering, time window, freshness, auth requirements, or error 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?

The description is compact, front-loaded with the purpose, and every sentence earns its place. The parameter docs are formatted clearly and immediately follow the main 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 simple two-parameter read tool with an output schema present, the description covers the necessary invocation details. It lacks guidance on ordering/freshness and when to choose this tool over siblings, but nothing critical prevents a correct 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?

The schema provides bare property names with no descriptions, so the Args section adds real value: it explains the no-market-prefix ticker format with KRX/US examples and the exact valid range for count. Both parameters become actionable.

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 opening sentence names a specific verb ('Get') and resource ('most recent executed trades') for a single symbol, which clearly distinguishes this from sibling tools like get_current_price or get_orderbook. The Korean term 체결 adds specificity without confusing the core purpose.

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

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

The description gives usage constraints (one symbol per call, count between 1 and 50) but does not state when to prefer this over alternatives such as get_candles or get_orderbook, nor does it mention any exclusions. Usage context is implied by the purpose but not 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states that the tool downloads and parses original filing documents, scans every relevant filing in the date range, and extracts specific fields. This makes it clear that the operation is read-only and non-mutating. It does not mention rate limits or error behavior, but the core behavioral traits are disclosed.

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

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

The description is well-structured: a one-line summary, a concise behavioral explanation, and clear parameter documentation. It includes useful context about the disclosure type and why document parsing is required. There is minor redundancy between 'reads each one to extract' and 'each filing's original document is downloaded and parsed,' but overall every section 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?

The description is complete for a three-parameter tool with an output schema: it explains the domain, the filtering scope, the extracted fields, the reason for document parsing, and all parameters. It does not discuss pagination, rate limits, or no-result scenarios, which would be useful but are not critical given the output schema and the description's overall clarity.

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%, but the description fully compensates by documenting all three parameters. It explains corp_code as the company's eight-digit Open DART code with a concrete example (Samsung Electronics is 00126380), and specifies start_date and end_date as filing-date search range boundaries with accepted formats YYYYMMDD or YYYY-MM-DD. This adds meaning well beyond the bare 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 resource: 'Get single sale/supply contract disclosures' and explains exactly what it does—finds every 단일판매ㆍ공급계약체결 filing for a company in a date range and extracts contract amount, period, counterparty, and related details. This clearly distinguishes it from generic sibling tools like search_disclosures or get_disclosure_document_text by focusing on a specific disclosure type and an aggregated extraction purpose.

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

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

The description gives clear context for when to use the tool: tracking order backlog (수주잔고) from disclosed sales contracts in a date range. It also explains why this specific tool is needed—there is no structured JSON API for this disclosure type in Open DART, so it downloads and parses original documents. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to select it appropriately.

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. It explicitly labels the operation as 'read-only' and clarifies that it returns currently sellable quantity from a single account, adding meaningful behavioral context beyond the name and schema.

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

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

The description is brief, front-loaded with the core purpose, and includes only necessary parameter details. Every sentence serves a purpose, and the Korean 'read-only' note reinforces without bloating.

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 two-parameter read-only tool, the description covers the operation, parameter provenance, and symbol format. An output schema exists, so return-value documentation is unnecessary. The description is adequately complete for correct invocation.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining both parameters: account_seq is the numeric value from get_accounts(), and symbol is a single ticker without market prefix with a concrete example. This adds essential meaning beyond the raw 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 ('Get') and resource ('how many shares ... can currently be sold from one account'), making the tool's function immediately clear. It is distinct from sibling tools like get_holdings or place_order, and the account-scoping helps differentiate it from broader market queries.

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

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

The description provides clear usage context by specifying that account_seq is the numeric accountSeq returned by get_accounts(), establishing a prerequisite and workflow. It does not explicitly name alternative tools or exclusion cases, but for a simple lookup tool the guidance 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?

No annotations are provided, so the description carries the behavioral burden. It discloses the underlying Open DART endpoints, the fact that it fetches filings filed within the date range, and that disclosure_type 'all' fetches every type in one call. This is solid behavioral context, though it omits potential error conditions, pagination, or rate-limit behavior.

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 front-loaded with the tool's purpose, then the data source, then parameter details. Although the disclosure_type list is long, every entry adds necessary meaning because the schema defines no enum. The Args block is well organized and each 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 4-parameter tool with no schema descriptions and no annotations, the description is quite complete: it covers all parameters, defaults, formats, and supported disclosure types. An output schema exists, so return-value details are not the description's responsibility. Minor gaps remain around error handling, invalid codes, and whether all is truly one request, but nothing critical is missing for invoking 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 0%, so the description fully compensates. It explains corp_code with an example, start_date and end_date format variants with examples, and disclosure_type with the complete enumeration of allowed values plus Korean labels and the 'all' default. This is exactly the information an agent needs to populate parameters correctly.

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 shareholder-return-related disclosure decisions over a date range, specifically board decisions on capital increases, reductions, and treasury stock activity. It is specific about resource and scope, and the listed disclosure types help distinguish it from dividend or general search siblings, though it does not explicitly name an 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?

Usage is implied rather than explicitly stated: the description indicates it is for fetching certain board decision disclosures from Open DART within a date range. It does not explicitly say when to use this tool versus similar sibling tools like get_dividend_info or search_disclosures, nor does it provide exclusion criteria.

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

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

With no annotations, the description must carry the behavioral burden. It conveys that this is a read-only lookup and documents input constraints like 'up to 200' and 'No market prefix,' but it does not mention error handling, rate limits, authorization requirements, or what happens with invalid symbols.

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: the purpose appears first, followed by a focused parameter explanation with examples. Every sentence adds value, with no redundant 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?

The single required parameter is thoroughly documented and an output schema exists, so return-value details are not the description's responsibility. The main gap is the lack of guidance on edge cases or failures, but for a simple lookup tool this is a minor omission.

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%, but the description fully compensates by explaining the symbols parameter: comma-separated tickers, up to 200, no market prefix, and concrete examples including '005930' and '005930,AAPL.' This goes far beyond the schema's bare string type.

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: 'Look up basic info (name, market, currency, status, shares outstanding...) for symbols.' This clearly identifies the tool as a reference-data lookup and differentiates it from sibling tools like get_current_price or get_orderbook.

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

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

The description implies usage for retrieving static basic stock information, but it does not explicitly state when to prefer this tool over alternatives or when not to use it. No exclusions or alternative tool names are provided.

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 of behavioral disclosure. It states that the tool 'gets' flags, implying a read operation, but does not describe response characteristics, potential missing-data cases, or any operational caveats beyond the input format.

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, stating the purpose immediately and then providing necessary argument details in a clear Args block. Every sentence contributes useful information without 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 single-parameter read-only tool with an output schema available, the description covers the essential purpose and input requirements. It is slightly incomplete in not offering contextual cues about when this warning data is relevant, but the core invocation information 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 description coverage is 0%, so the description must compensate. It does so effectively by explaining the symbol parameter, requiring a single ticker without market prefix, and providing a concrete example ('005930'). This adds meaningful guidance beyond the bare schema property.

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

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

The description clearly states the tool's function: retrieving investment-caution flags (매수 유의사항) for a single KRX symbol, with concrete examples like 관리종목/VI. It distinguishes itself from sibling quote and company-data tools by focusing specifically on warning flags.

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 input format guidance ('single ticker symbol, no market prefix') but does not explain when to use this tool versus alternatives such as get_stock_info or get_current_price. No explicit when-not-to-use or alternative selection criteria are provided.

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 of behavioral disclosure. It reveals the filtering behavior and clarifies that 'group' includes supergroups, which is helpful. However, it does not mention whether authentication is required, whether results are paginated, or any other side effects, though the verb 'List' suggests 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?

The description is one short, front-loaded sentence. It states the primary action first and then adds the only parameter semantics that matter, with no redundant or filler language.

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

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

The tool is simple: one optional parameter, no nested objects, and an output schema is present. The description covers the tool's purpose and the parameter's valid values, which is sufficient context for correct invocation. Return values are already documented by the output schema, so the description does not need to explain them.

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 only provides a string 'chat_type' with a default, leaving 0% schema description coverage. The description compensates fully by enumerating the allowed values: all, channel, group (including supergroups), or user. This gives the agent the exact vocabulary needed to set the parameter correctly.

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

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

The description clearly states the action ('List') and the resource ('Telegram dialogs'), making the core purpose unambiguous. It does not explicitly differentiate from sibling tools like get_channel_info or get_messages, but the resource and filter scope are specific enough that the tool is identifiable.

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: call this when you need to list Telegram dialogs, optionally filtered by chat type. It does not explicitly mention when not to use it or point to alternatives, such as get_messages for message-level retrieval, so the guidance is mostly 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 full responsibility, and it fully discloses the side effects: the order is replaced under a new ID, the original becomes inactive with REPLACED, reuse of the old ID fails with HTTP 409, and the caller must use new_order_id. This is exactly the kind of behavioral context agents need.

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?

Every sentence carries a unique, decision-relevant fact. The most important constraint (confirm=True) is front-loaded, and the market-specific rules and replacement behavior are arranged in clear paragraphs with no filler.

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

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

The operational behavior is thoroughly covered, and an output schema exists to describe return values. Still, for a mutation with eight parameters and no annotations, the missing semantics for account_seq, order_type, and confirm_high_value_order leave the calling contract incomplete for an agent.

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 adds meaning for symbol, confirm, price, quantity, and order_id, which is valuable given 0% schema coverage. However, two required parameters (account_seq and order_type) are never explained, and confirm_high_value_order is not distinguished from confirm, leaving important invocation details underspecified.

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 ('Modify') and resource ('a live pending order'), and the replacement semantics make it easy to distinguish from place_order/cancel_order. No sibling ambiguity remains.

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 explicit when-not guidance: US-market quantity changes and KR-market quantity increases must be done by canceling and placing a new order. It stops short of stating the positive selection rule ('use this for allowed price/quantity changes') but that is strongly 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?

With no annotations, the description carries the full burden, and it only partially addresses this. It discloses that this is a live order and adds the important constraint that quantity and orderAmount are mutually exclusive, with orderAmount for US MARKET orders. However, it does not disclose that a live order may execute immediately, that the order may be irreversible once filled, or how the confirm and confirmHighValueOrder fields affect behavior.

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, front-loaded with the purpose, and does not waste words. The second paragraph is a little redundant with the schema field names, but it still earns its place by adding the exclusivity and US MARKET constraint.

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 11-parameter live trading tool with no annotations, the description is not complete enough to invoke correctly. It fails to define side and order_type, which are required, and it does not explain price conditions, time_in_force semantics, confirmation behavior, or clientOrderId purpose. The output schema may cover return values, but the missing invocation guidance is significant.

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

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

Schema coverage is 0%, and several required parameters such as side, order_type, and account_seq are not explained at all. The description adds only two parameter-related insights: quantity/orderAmount mutual exclusivity and orderAmount's restriction to US MARKET orders. The wire-field list mostly repeats schema names without clarifying allowed values, formats, or conditions.

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 'Submit' with a clear resource 'stock order' and immediately distinguishes this as a live, order-creating action. This differentiates it from sibling tools like cancel_order, modify_order, and get_order. Mentioning 'quantity- or amount-based' adds useful scope.

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 tool is for submitting real stock orders, but it does not explicitly state when to prefer it over alternatives or exclusions. It gives no guidance about when not to use it, such as for paper trading, testing, or modification of existing orders. The usage context is mostly inferred from the word 'Submit' and the sibling tool names.

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 present, so the description must carry the behavioral burden. It does disclose meaningful behavior for listed_only ('return only companies with a stock code') and limit ('Maximum number of results'), but it does not describe the output shape, no-match behavior, or potential errors. That is adequate for a simple read-only search, but it is 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?

The one-sentence purpose statement is front-loaded and followed by a compact, well-organized Args block. Every sentence contributes either purpose or parameter semantics, with no fluff or redundant content.

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

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

For a simple three-parameter search tool, the description is nearly complete: it covers all parameters, gives examples, and explains the key flag. It lacks an explicit statement about the return format or authentication expectations, but this is a minor gap for a basic lookup operation in a broader ecosystem.

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

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

Although the schema provides titles and defaults for all three parameters, the description adds substantial meaning: concrete query formats and examples, the semantic effect of listed_only, and the 1-50 range for limit, which is not present in the schema. This goes well beyond what the structured schema provides.

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

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

The opening sentence uses a specific verb ('Search') with a clear resource ('DART companies') and lists the exact accepted query types: company name, stock code, or corp code. Examples such as 삼성전자 and 005930 make the search scope concrete and distinct from the sibling profile, statement, and disclosure tools.

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

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

The description implies when to use the tool: when you need to find a DART company by name, stock code, or corp code. However, it does not explicitly state when to prefer this over the many sibling retrieval tools or provide any exclusions, so the usage guidance is largely 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?

With no annotations provided, the description carries the full burden, and it does this well. It states that the tool uses a specific Open DART endpoint, returns only filing metadata, and that keyword matching happens after the API response. These behavioral traits go well beyond the parameter schema and help set accurate expectations.

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 front-loaded with a clear one-sentence purpose, followed by a useful distinction from a sibling, and then a structured Args section. There is no filler or redundant repetition of the schema; each part serves a purpose.

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 an output schema exists and all parameters are thoroughly documented, the description is complete for effective use. It clarifies the return type, names the follow-up tool for content retrieval, and discloses the local filtering limitation. No critical operational gap remains for an agent to misuse the 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 0%, so the description must compensate, and it does. Every parameter is explained: corp_code includes a concrete example, date formats are given, pblntf_ty lists all valid Korean category codes, and keyword's post-fetch behavior is clarified. This is exemplary parameter documentation.

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 and resource: 'Search DART disclosure filings within a date range.' It also distinguishes itself from the sibling get_disclosure_document_text by stating that it returns filing metadata only and that content retrieval belongs to the other tool. This gives an agent immediate clarity about the tool's scope.

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 tells the agent when to use a different tool: use get_disclosure_document_text with a receipt_no to read content. It also explains that keyword filtering is applied locally after fetching because DART has no title-search parameter, which prevents false expectations about API-side filtering. This is clear guidance for tool selection and invocation.

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 does this well by explaining result scoping, default date behavior, UTC interpretation, and the dialog-by-dialog scanning caveat. It also lists the exact per-match return fields, which goes beyond what is structurally required.

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 and front-loaded with the core purpose, followed by useful parameter details and a return value list. Each sentence adds meaningful information without unnecessary fluff, though the parameter explanations could be more visually structured.

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

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

Given the tool has five optional parameters and an output schema, the description covers the most critical behavioral aspects: file type semantics, date range behavior, and global search limitations. The main gaps are the lack of explanation for query and limit, but the output schema and parameter names partly mitigate this.

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 provides rich semantics for file_type and since_date, including allowed values, exclusions, defaults, and timezone handling. However, chat, query, and limit are left entirely unexplained, and schema description coverage is 0%, so the description only partially compensates for the missing parameter documentation.

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 opening line 'Find messages carrying files, globally or in one chat' uses a specific verb and defines the resource and scope. It clearly references search_messages as a related sibling but does not explicitly distinguish when to use this tool versus the alternative for text-based search.

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 contextual usage guidance, such as the global-search caveat and the default 7-day window, but does not explicitly state when to prefer search_files over search_messages or when to use download_file after finding files. Usage is implied rather than explicitly contrasted with alternatives.

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 excellently. It discloses non-obvious behaviors: default 7-day window, UTC interpretation of timezone-less values, and the sequential dialog-scanning bias in global search that affects result selection.

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?

Every sentence adds necessary context. The first line states the core action, and the following sentences pack in important semantics without fluff. The structure is front-loaded and easy to scan.

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

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

The description covers the tool's core behavior, parameter nuances, default behavior, and a significant caveat about global search ordering. An output schema exists, so return-value details don't need to be repeated here. 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?

Schema description coverage is 0%, so the description compensates fully. It explains chat (omit for global), since_date (ISO 8601 default behavior, timezone handling), limit (stops global search), and query (searched in message text). This goes well beyond the raw 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 and resource: 'Search message text globally or in one chat.' It clearly distinguishes the two modes and, by naming 'message text,' separates this from siblings like get_messages, search_files, or search_disclosures.

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

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

The description gives clear context for when to use global vs. scoped search and how to control the time window via since_date. It doesn't explicitly name alternative tools or exclusions, but the usage conditions are stated well enough for an agent to decide.

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 state the three checks performed and uses the non-mutating verb 'check,' but it does not describe failure behavior, side effects, or network interaction details.

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 clear sentence with no filler. Every word contributes meaning, and the main action is front-loaded.

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

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

For a simple zero-parameter tool with an output schema, the description sufficiently captures what is being verified. It does not explain how to interpret results, but the output schema is available for that; the main missing element is broader usage context, which is already covered by the usage_guidelines dimension.

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 description coverage is 100%, so there is no parameter burden for the description. Per the baseline for zero-parameter tools, a 4 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 ('Check') and clearly identifies the resource and scope: Telegram credentials, StringSession connection, and account authorization. It distinguishes itself from sibling test_connection tools by naming Telegram explicitly.

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

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

The intended usage is implied: use this tool when you need to verify Telegram credentials and connectivity. However, it provides no explicit guidance on when to use it over sibling connection-test tools or when it should be run relative to other Telegram operations.

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 of behavioral disclosure. It indicates a verify-style action and that a message is returned, but it does not disclose side effects, auth dependencies, or behavior when the connection fails; it also leaves the role of the message parameter unstated.

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 filler. Every word contributes to stating the tool's purpose, which is appropriate for a simple one-parameter health-check method.

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

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

The tool is simple and has an output schema, so the description need not describe return values. However, it leaves the required message parameter unexplained and does not differentiate the Toss test from sibling test_connection tools, so the overall guidance is adequate but incomplete.

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

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

Schema description coverage is 0%, and the description does not explain the only parameter, 'message', beyond the schema's bare title. The description does not compensate for the schema gap by stating what the message should contain or how it is used.

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 action—return a message to verify the MCP server process—but it is generic and does not distinguish toss_test_connection from sibling health-check tools like dart_test_connection, telegram_test_connection, or finance_test_connection. It also says 'MCP server process' rather than identifying the Toss-specific connection being tested.

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 provided about when to use this tool versus the many sibling connectivity/credential tools such as check_toss_api_credentials, dart_test_connection, and finance_test_connection. The agent is left to infer from the name alone that this is a Toss connection health check.

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