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 full behavioral burden. It discloses the key safety behavior: credentials are checked but not exposed. It also implies a local, non-mutating check rather than an API call. It does not specify success/failure return details, but the presence of an output schema reduces that 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?

A single, tightly written sentence that names the action, the subject, and a critical non-exposure guarantee. Every word earns its place; there is no filler or redundancy.

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

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

For a zero-parameter credential-presence checker, the description is highly complete: it states what is checked and the safety constraint. The output schema presumably covers return values. It could further clarify how this differs from toss_test_connection, but that is a minor omission given the tool's simplicity.

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 is empty with zero parameters, so there is no parameter documentation burden. The description appropriately focuses entirely on the tool's action rather than arguments. Baseline 4 for a zero-parameter tool is appropriate.

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

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

The description states a specific verb ('Check'), a specific resource ('TOSS_CLIENT_ID / TOSS_CLIENT_SECRET'), and the precise condition being tested ('were loaded'). It also adds a distinct safety qualifier ('without exposing them'), which separates it from sibling tools like toss_test_connection that actually test connectivity rather than checking local credential presence.

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 this tool is for verifying that TOSS credentials are present before use, rather than for testing a live connection or performing any operation. It does not explicitly name when-not-to-use or alternatives, but the context is clear enough that an agent would know this is a preflight environment check, especially alongside toss_test_connection.

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 full behavioral disclosure burden. The verb 'List' clearly implies a read-only operation, and the description explains what each account result contains (accountSeq). It does not explicitly state a read-only guarantee or discuss edge cases like an empty account list, but for a zero-parameter list operation this is reasonably 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 compact and front-loaded. The first sentence states the tool's core purpose, and the second provides the crucial downstream usage context. No filler or repetition.

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

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

For a simple, parameterless list tool with an output schema available, the description is complete. It names the resource, identifies the key return field (accountSeq), and explains why that field matters to sibling tools, giving the agent everything needed to invoke and chain 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?

There are no parameters, so the schema declares fully that none are required. The description adds no parameter-level detail, which is appropriate and warrants the baseline score for zero-parameter tools.

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, unambiguous action: 'List your Toss Securities accounts.' It names the resource (accounts) and immediately clarifies the primary output (accountSeq). Though there is no direct sibling comparison, no other sibling tool lists accounts, so it is clearly distinguished by its specific verb and resource.

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 this tool to downstream usage: accountSeq is required by get_holdings, get_buying_power, get_commissions, and get_sellable_quantity as their account_seq argument. This tells an agent exactly when to call this tool — before those account-specific tools — making invocation ordering obvious.

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 provided, the description carries the full burden. It discloses pagination semantics via the 'before' cursor and 'nextBefore' from a prior response, explains the adjusted-price flag, and notes the single-symbol limitation. It does not mention auth, rate limits, or invalid-symbol behavior, but these are minor for a read-only data fetch.

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

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

The one-sentence summary is front-loaded and precise. The Args list is organized and non-redundant, with each parameter explanation adding necessary detail. The Korean translation is a minor redundancy but does not detract.

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?

An output schema exists, so return values need no description. The definition covers every parameter's constraints and defaults, provides examples, and explains the pagination flow, making the tool callable without external docs. It omits explicit auth or rate-limit context, but for a data-retrieval tool this is not critical.

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 Args section thoroughly documents all five parameters: accepted interval values ('1m', '1d'), count range (1-200), cursor semantics, symbol format examples, and the adjusted flag. This fully compensates for the uninformative 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 opening sentence states a specific verb and resource: 'Get OHLCV candle-chart data for a single symbol.' This clearly distinguishes it from sibling tools like get_current_price or get_recent_trades, and the single-symbol constraint is 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 provides clear context for the tool's purpose and includes constraints like only one symbol per call and cursor-based pagination, but it does not explicitly name alternatives or state when not to use this tool. The usage context is 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the source (Open DART) but does not state whether authentication is required, how fresh the data is, whether it is read-only, or if there are rate limits or error conditions.

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 and immediately states the tool's purpose, then follows with a clear parameter breakdown and a useful example. Every sentence earns its place without redundant detail.

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

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

For a simple one-parameter tool with an output schema, the invocation details are mostly sufficient. However, the description omits when to use this tool instead of get_company_profile_by_query, and does not mention any prerequisite like an Open DART API key, which is a notable gap given the sibling tools include check_dart_api_key.

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

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

The schema provides only the parameter name and type with 0% coverage, but the description compensates well by explaining that corp_code is an eight-digit Open DART corporation code and giving a concrete example (Samsung Electronics is 00126380). This gives the agent enough context to supply 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 tool retrieves official company information from Open DART, with a specific verb and resource. However, it does not explicitly distinguish itself from the sibling get_company_profile_by_query, which likely serves a similar purpose via different lookup criteria.

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

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

The description provides no guidance on when to use this tool versus alternatives like search_company or get_company_profile_by_query. It only explains the required corp_code argument, with no mention of preferred scenarios or exclusions.

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

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

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 behavioral burden itself. It states that the tool uses an external Open DART endpoint, returns every line item across the balance sheet, income statement, and other statements, and is scoped to a single business year and report type. It does not cover auth or rate limits, but for a read-only financial-data fetch the core behavior is clear.

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

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

The description is front-oaded with the core purpose and uses a compact Args block. The phrase 'every line item' appears twice and the endpoint name adds mild redundancy, but it stays under roughly 130 words and contains 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?

For a 4-parameter external-data tool with no schema descriptions and no annotations, this description is largely complete: it covers every parameter, defaults, examples, allowed values, and the nature of the response. The only notable gap is explicit routing guidance between this and the sibling get_financial_statements.

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 schea has no descriptions (0% coverage), but the description fully compensates: it defines corp_code with an example, year format, all four allowed report_type values, and both fs_div values with their defaults. This is exactly the semantic content the schema 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 a specific verb and object: 'Get the complete financial statement (every line item) for one period.' It further identifies the Open DART full-statement endpoint and explicitly enumerates which statements it covers, making it distinguishable from the tersely named 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?

The wording 'complete' and 'every line item' implies this is the tool for full financial-statement detail, but it never names alternatives or gives an explicit when-to-use/when-not-to-use rule. No mention of get_financial_statements as the lighter or summary alternative, so the agent must infer the boundary.

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 provided, the description carries the behavioral disclosure burden. It names the underlying Open DART endpoint, explains that data covers start and end of each reporting period, and lists the specific shareholder fields returned. This is substantive transparency for a read-only status lookup, though it does not discuss API-key requirements or error 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 well-structured and front-loaded with the core purpose, followed by the data source and a clean Args block. Every sentence adds necessary information: the example corp_code is useful, the report_type list is explicit, and there is 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?

Given the four parameters, no annotations, and an output schema that presumably covers return values, the description is largely complete. It documents all parameters, the data source, the contents of the response semantics, and the supported reporting periods. It only lacks explicit guidance on choosing among sibling shareholder-related tools, but that is secondary to making 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?

Schema description coverage is 0%, so the description must fully document parameters, and it does. It explains corp_code as an eight-digit Open DART code with a concrete example, defines start_year and end_year as four-digit business years, and enumerates all report_type values including Korean names and 'all' semantics.

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

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

The description clearly states the tool gets major/largest-shareholder ownership status (최대주주 현황) across years and describes the data returned: each major shareholder's name, relationship to the company, and share ownership at reporting period boundaries. It is distinct enough from siblings like get_major_shareholder_changes and get_minority_shareholder_status, though it does not explicitly contrast itself with them.

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: call this when you need major-shareholder ownership status across years, with parameters for year range and report type. However, the description does not explicitly state when to prefer this over related siblings such as get_major_shareholder_changes or get_minority_shareholder_status, nor does it mention exclusions.

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

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

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?

There are no annotations, so the description carries the behavioral burden. It does disclose the upstream Open DART endpoint and the specific metrics returned, which adds real context. It stops short of covering auth prerequisites, rate limits, error behavior, or data availability constraints, all of which would be useful without annotations.

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

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

The description is front-loaded with a clear one-line purpose, then moves directly into a compact Args block. There is no filler, and 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?

An output schema exists, so explaining the return structure is unnecessary. The description covers the endpoint, all parameters, and the reported data metrics sufficiently for correct invocation. The remaining gap is the lack of explicit sibling routing and behavioral caveats, which are mostly scored 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?

Schema description coverage is 0%, but the Args section fully compensates: it explains corp_code format with an example, specifies four-digit years with examples, and enumerates every report_type value with Korean labels and the meaning of 'all'. This is exactly the information an agent needs to fill the 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 opening sentence names a specific verb ('Get'), a specific resource ('minority/small shareholder status'), and a time dimension ('across years'), reinforced by the Korean term. This makes it immediately distinguishable from the sibling get_major_shareholder_status even without an explicit comparison.

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 is implied by the tool name and first sentence: fetch minority shareholder status data. However, the description never explicitly says when to prefer this tool over get_major_shareholder_status or other shareholder-related siblings, and it offers no alternatives or exclusions.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. 'Get' clearly indicates a read operation, and 'all available details' plus 'execution information' gives some sense of scope. However, it does not explain any prerequisites, edge cases, or what happens when the order is not found or when account_seq is mismatched.

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. 'Get all available details' immediately states the action and scope, and 'including execution information' earns its place by adding useful 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?

Although an output schema exists and covers return values, the description omits key context needed for correct invocation: what account_seq means, how the two parameters interact, and how this tool differs from get_orders. With no annotations and minimal schema descriptions, the definition leaves material gaps 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?

Schema description coverage is 0%, so the description needed to compensate by explaining the two required parameters. It only weakly implies order_id through 'one order' and never explains account_seq or how account_seq relates to the order lookup. The agent is left to infer the parameter semantics from names and types alone.

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 ... one order') and adds 'including execution information,' which clarifies what details are returned. It does not explicitly name sibling tools, but the singular 'one order' helps differentiate it from list-style tools like 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 phrase 'for one order' implies this is for fetching a single order's full details, distinct from get_orders or place_order. However, there is no explicit when-to-use guidance, exclusions, or mention of alternatives such as using get_orders for collection-level queries.

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 communicates that this is a read-style 'Get' operation and that only one symbol is accepted, but it does not disclose depth of the order book, data freshness, or any access 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 with the core purpose, followed by a tightly scoped Args block. The Korean parenthetical is minor redundancy but does not meaningfully hurt readability.

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

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

For a single-parameter read tool with an output schema available, this description covers what the agent needs to invoke it correctly. It does not discuss return structure in prose, but the output schema covers that, so this is sufficient.

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 for the single 'symbol' parameter by explaining the ticker format, the lack of a market prefix, giving concrete KRX and US examples, and emphasizing the one-symbol-per-call rule.

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 ('Get'), a specific resource ('current bid/ask order book'), and a clear scope ('for a single symbol'). This is immediately distinguishable from sibling tools like get_current_price or get_candles based on the resource alone.

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 when an order book snapshot for one symbol is needed, but it does not explicitly state when not to use it or mention alternative tools. It does provide useful invocation constraints like one symbol per call.

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 for behavioral disclosure, but it only names filters. It does not explain sort order, how cursor/limit pagination works, what status values are valid, whether results are scoped to the required account_seq, or any other observable 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 a single sentence with the action and resource front-loaded. It is compact and readable, though 'spec's' is vague filler and the filter list does not exactly match the schema parameter names.

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 seven parameters, a required account_seq, and a cursor-based pagination field, the description is incomplete. It does not mention the mandatory account_seq, pagination behavior, how dates should be formatted, or how this endpoint relates to get_order. The output schema may cover return values, but the input behavior is underspecified.

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 add some meaning by identifying status, symbol, from, to, cursor, and limit as filters, but 'from'/'to' do not exactly match from_date/to_date, account_seq is omitted entirely despite being required, and no value formats or status options are given.

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 ('List') and resource ('orders'), and lists the filter dimensions, so it is immediately clear this is the plural listing endpoint and can be distinguished from the singular get_order. The phrase 'spec's' is somewhat obscure, but the core purpose is clear enough.

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 on when to use get_orders versus related siblings like get_order, get_holdings, or get_recent_trades. Use is only implied by the command 'List orders', with no exclusions, prerequisites, or alternative routing.

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

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

With no annotations, the description carries the transparency burden. It communicates a read-only 'Get' action and the 'today's' temporal scope, which is helpful. But it does not disclose auth requirements, error behavior, or data-source details, leaving some room for ambiguity.

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

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

The description is short and front-loaded with the core purpose. The Args block is compact. The Korean parenthetical is mildly redundant for an English interface but does not hurt clarity.

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 query tool with an output schema, the description is nearly complete: it gives the query scope, symbol format, and a concrete example. It does not explicitly route users away from sibling price tools, but that is not required for correct invocation.

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

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

The schema only provides the parameter name and type, so the description's Args section adds essential meaning: 'single ticker symbol, no market prefix, e.g. 005930.' This fully compensates for the 0% schema description coverage.

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

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

The description clearly states the specific action: getting today's upper/lower price limits for a single symbol. The resource, price limits, is distinct from sibling tools like get_current_price and get_orderbook, so an agent can identify what this tool does.

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 context: it is for a single symbol's daily price limits. However, it does not explicitly compare against alternative tools or state when not to use it. The guidance is useful but 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 the behavioral disclosure burden. It adds useful constraints: no market prefix, accepted count range 1-50, and single-symbol-only behavior. However, it does not explicitly state that this is a read-only operation, describe the response shape, or mention any authentication/rate-limit implications.

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

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

The description is compact and well-structured: a one-sentence summary followed by a short Args block. Every sentence adds value, and the most important information 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?

The description covers both parameters and key invocation constraints, which is adequate for basic use. But because there is no output schema or annotations, it would benefit from a note about the returned trade fields or ordering, and possibly a pointer to sibling tools such as get_current_price or get_orderbook.

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 bare property names, so the description compensates well. It explains symbol format with concrete examples ('005930', 'AAPL'), states that no market prefix is used, emphasizes one-symbol limit, and defines count as between 1 and 50. This is genuinely useful beyond the schema.

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

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

The description opens with a clear action and resource: 'Get the most recent executed trades (체결) for a single symbol.' This distinguishes it from siblings like get_current_price or get_orderbook by the data type, though it does not explicitly name any alternative tool.

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 first sentence and parameter notes provide clear context for when to use the tool: when recent executed trades for a single symbol are needed. It also states the constraint that only one symbol is accepted per call. However, it does not mention any sibling alternatives or exclusions such as 'use get_orderbook instead.'

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 states that each filing's original document is downloaded and parsed because there is no structured JSON API, and it lists the extracted fields (contract amount, period, counterparty). This gives material behavioral insight beyond the tool 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 well-organized: a one-line summary, a purpose/behavior paragraph, and a clean Args block. Every sentence adds information—the Korean disclosure type, the extracted data, the lack of structured API, and clear parameter semantics—without 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?

The description covers the tool's purpose, input semantics, behavior, and why downloading/parsing is necessary. Since an output schema exists, the description does not need to explain return values. Minor gaps such as pagination, rate limits, or potential cost of reading many filings are not mentioned, but the available context is strong enough for correct invocation.

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

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

The input schema provides only type and title for each parameter, with 0% description coverage. The description compensates fully by explaining each parameter: corp_code is the eight-digit Open DART code with a concrete example, and start_date/end_date are defined as filing-date range boundaries with accepted formats YYYYMMDD or YYYY-MM-DD.

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 then expands with 'Finds every 단일판매ㆍ공급계약체결 filing for a company in a date range.' This clearly distinguishes it from sibling tools like search_disclosures or get_disclosure_document_text by identifying both the exact disclosure type and the extraction behavior.

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 is used for tracking order backlog from disclosed sales contracts and notes that this disclosure type has no structured JSON API, which explains why document parsing is needed. It does not explicitly name alternatives or exclusion conditions, but the context is strong enough for an agent to infer when this tool is appropriate.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly marks the operation as 'read-only' and clarifies it only retrieves currently sellable shares, implying no side effects. It does not cover auth or rate limits, but for a simple read query this is reasonably 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 compact and well-structured: a one-sentence purpose statement is followed by two concise parameter bullets. There is no filler, and the core behavior is front-loaded before the arguments.

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-only query with an output schema present, the description provides the essential information: purpose, read-only nature, account_seq source, and symbol format. Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must fully compensate for parameter documentation. It explains account_seq as the numeric accountSeq returned by get_accounts(), and symbol as a single ticker with no market prefix and an example. Both required parameters are meaningfully documented beyond the bare schema definitions.

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 how many shares of a symbol can currently be sold from one account.' It clearly identifies the operation as a read-only quantity query and distinguishes it from sibling tools like get_holdings, get_buying_power, or place_order by focusing on sellable quantity for a single 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 description gives clear usage context: account_seq should be the numeric accountSeq from get_accounts(), and symbol must be a bare ticker without a market prefix. It implies when to use this tool, but it does not explicitly name alternatives or state when not to use it, so it falls short of full routing guidance.

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

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

No annotations are present, so the prose carries the full burden of behavioral disclosure. The description usefully clarifies that the date range applies to filing dates and that this is a fetch from external DART endpoints, but it does not mention API-key requirements, rate limits, pagination, or empty-result behavior. These are meaningful gaps for an external 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 well-structured: purpose first, endpoint context second, then a clean Args block. The disclosure-type list is long but necessary because the schema provides no enum values, and every line carries useful information without 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?

Given that an output schema exists, return-value documentation is handled separately. The description fully documents all four inputs, the date semantics, and the available disclosure types. It is only missing operational details such as DART API-key prerequisites and behavior when no disclosures are found, so a perfect completeness score is not warranted.

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 parameter documentation in the description is essential and fully compensates. It defines corp_code with format and a concrete example, start_date and end_date with accepted formats and examples, and disclosure_type with all valid values, Korean labels, and the default. An agent can construct a correct call from this text alone.

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 shareholder-return-related disclosure decisions over a date range.' It then enumerates exactly what it fetches (capital increases, capital reductions, treasury stock activity), which makes the tool readily distinguishable from siblings like get_dividend_info or 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?

The description conveys a clear usage context: fetching board disclosure decisions from Open DART major-matters reports within a filing-date range, with a defined set of disclosure types. It does not explicitly name sibling alternatives or state when not to use this tool, so it stops short of a 5.

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

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

With no annotations, the description 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 burden of behavioral disclosure. It does add useful context about the kind of flags returned and symbol formatting, but it does not explicitly state whether the operation is read-only, whether any permission is needed, or how errors or empty results are handled.

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 conveys the tool's purpose, and the Args section adds only necessary parameter details. There is no redundant 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?

For a simple one-parameter tool with an output schema, the description covers the essential context: what kind of data is returned and how the input must be structured. It is slightly incomplete only in not offering any guidance about choosing between this and related warning/stock-information 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?

The input schema provides no description for the 'symbol' parameter, so the description fully compensates. It specifies that the symbol must be a single ticker, must not include a market prefix, and gives a concrete example ('005930'), which is exactly what an agent needs to format the argument 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 a specific action and resource: getting investment-caution flags for a single KRX symbol. It further clarifies the domain with concrete examples like 관리종목/VI, making it easily distinguishable from sibling tools that focus on prices, orders, or company profiles.

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 on when to use the tool: when you need caution flags for one KRX symbol. It also provides an important usage constraint by requiring a single ticker without a market prefix. However, it does not explicitly name alternatives or state when not to use this 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 behavioral disclosure burden. It does disclose the filtering behavior: chat_type filters to all, channel, group (including supergroups), or user. However, it does not mention pagination, ordering, authentication, or other runtime behavior, leaving a moderate gap.

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

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

Two short sentences with no filler; the verb-resource statement is front-loaded and the parameter detail follows directly. Every word earns its place.

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

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

For a simple one-parameter list operation with an output schema, the description covers both the operation and filter semantics adequately. A small gap remains in not mentioning when to prefer this over sibling message/channel tools, but the low complexity and existing output schema keep it largely complete.

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

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

Schema description coverage is 0%, but the description fully compensates for the single parameter by enumerating the accepted chat_type values and clarifying that "group" includes supergroups. This is exactly the semantic guidance the schema 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 the specific verb-resource pair "List Telegram dialogs", which clearly identifies what the tool does. It does not explicitly compare itself to siblings like get_messages or get_channel_info, so it stops 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?

Usage context is implied by "List Telegram dialogs" and the chat_type filtering sentence, but no when-to-use or when-not-to-use guidance is provided. The agent must infer that this is the right tool for enumerating dialogs rather than messages or channel info.

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 of disclosing side effects. It does flag that the order is 'live,' but it does not warn that submitting can execute immediately, commit funds, or require confirmation for high-value orders, despite listing confirmHighValueOrder as a wire field. This is thin coverage for a real-money mutation.

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 the core purpose, and the second adds the most decision-relevant parameter constraints. The wire-field list is slightly redundant with the schema, but it provides useful camelCase mapping and does not add fluff.

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

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

For an 11-parameter, high-stakes order submission tool with no annotations and no schema descriptions, the description leaves meaningful gaps: valid values for side/order_type/time_in_force, the semantics of confirm, and the behavior after submission are absent. An output schema exists, so return-value documentation is not required, but the invocation requirements are 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 there are 11 parameters, so this dimension depends heavily on the description. The description adds two useful facts—quantity and orderAmount are mutually exclusive, and orderAmount is only for US MARKET orders—but it leaves side, order_type, time_in_force, price, confirm, and client_order_id semantics to the agent's assumptions.

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 'Submit a live quantity- or amount-based stock order,' giving a specific action and resource. This clearly distinguishes place_order from sibling order-management tools like cancel_order, modify_order, and get_order(s), which serve different verbs on the same resource.

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 tool's purpose as the new-order entry point is implied by 'Submit a live... order,' but the description never explicitly contrasts it with modify_order/cancel_order or states conditions like 'use modify_order for existing orders.' It does provide context that amount-based orders are restricted to US MARKET orders, which helps select the right invocation mode.

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 burden of behavioral transparency. It discloses the endpoint, the limited return payload, and the post-fetch keyword behavior, which is genuinely useful. It does not cover error cases, API key requirements, or rate limits, but for a straightforward search tool the core behavior is well 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 front-loaded with the core purpose and the most important limitation (metadata only). The parameter list is structured and every line adds value, with example values and format hints. No fluff or repetition.

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

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

The description covers the purpose, parameters, output scope, and the key alternative tool. An output schema exists, so return-value details need not be repeated. Minor gaps include no mention of authentication prerequisites or error behavior, but these are secondary for correctly selecting and invoking this search 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 fully compensate. It does: it explains corp_code with a concrete example, gives date format variants, documents every pblntf_ty category code, and clarifies that keyword is applied after fetching since the API lacks title search. This is far richer than 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 opens with a specific verb and resource: 'Search DART disclosure filings (공시검색) within a date range.' It clearly distinguishes itself from the sibling get_disclosure_document_text by stating that this tool returns metadata only, while that sibling reads filing content. An agent can immediately tell what this tool does and how it differs from related 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 explicitly routes the agent: use get_disclosure_document_text with a receipt_no to read content, since this tool only returns metadata. It also explains that keyword filtering is applied client-side with no API-side title search, which informs usage expectations. This is direct, practical when-to-use 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 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 only states the tool returns a message and verifies the process is working, but does not say whether a network request is made, whether credentials are required, what failure behavior looks like, or what the required 'message' parameter does.

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 sentence with no wasted words, and the core action is front-loaded. It is appropriately sized for the simplicity of a health-check tool, though brevity comes at the cost of parameter clarity.

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?

Despite being a simple tool, the description is incomplete for reliable invocation: the required parameter is unexplained, usage guidance versus sibling test tools is missing, and there is no indication of what the returned message will contain or validate. The output schema exists but does not compensate for the missing parameter semantics.

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 explain the required 'message' parameter. It does not; the mention of 'Return a message' refers to the output, not the input meaning. The parameter remains ambiguous: is it echoed, sent to a server, or simply a required arbitrary string?

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 action ('Return a message') and its purpose ('verify that the MCP server process is working'). It is specific enough to distinguish from credential-check tools like check_toss_api_credentials, though it does not explicitly differentiate among the several test_connection sibling 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?

No guidance is provided about when to use this tool versus check_toss_api_credentials, dart_test_connection, telegram_test_connection, or finance_test_connection. Since multiple near-sibling test and credential-check tools exist, explicit usage conditions or exclusions would be valuable but are absent.

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