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

With no annotations provided, the description carries full behavioral burden. It discloses the conditional dependency on ODDSRAIL_BUILDER_CODE, which is a useful behavioral trait. However, it does not explicitly state whether this is a read-only operation, nor describe any side effects, authentication requirements, or rate limits. The mention of 'stats' implies non-mutating, but this is left to inference.

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 that front-loads the core purpose. It contains no redundancy or filler. However, it is brief to the point of under-specification, so it is not a model of completeness, but as far as conciseness and structure go, it is efficient.

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

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

Given the tool's moderate complexity (conditional output, external environment variable, and one undocumented parameter), the description is notably incomplete. It does not explain the time_period parameter, does not describe the output shape (despite an output schema existing), and does not clarify the semantics of 'matched trades'. An agent would struggle to use this correctly without additional context.

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

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

The input schema has a single optional parameter 'time_period' with a default of 'WEEK', yet schema description coverage is 0% and the description makes no mention of it whatsoever. The agent is given no information about acceptable values, format, or the meaning of 'time_period'. Since the schema itself has no enums or explanations, the description must compensate, but it entirely fails to do so.

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 resource ('builder attribution stats') and details two concrete outputs: the public leaderboard and matched trades when ODDSRAIL_BUILDER_CODE is set. This distinguishes it from sibling tools focused on markets, orders, or positions. However, it does not explicitly name what 'stats' encompasses beyond those two items, so it is clear but not exhaustive.

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 on when to use this tool versus alternatives. With 21 sibling tools covering markets, orders, and balances, the description does not state any condition for selection, nor any exclusions. The only contextual hint is the conditional ODDSRAIL_BUILDER_CODE dependency, which is a behavioral condition rather than a usage instruction.

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 the dry-run behavior, which is a notable behavioral trait beyond the schema. However, it omits other potentially relevant behaviors such as error handling, idempotency, or side effects (e.g., what happens if the order is already canceled). The single disclosed trait is valuable but the coverage is thin.

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, short sentence that conveys the core purpose and a key behavioral nuance. There is no redundancy or filler; every word contributes to the tool's understanding.

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

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

Given the tool's simplicity and the presence of an output schema, the description covers the essential purpose and dry-run behavior. However, it lacks guidance on when to use the tool relative to alternatives, and does not mention error conditions or the expected outcome for non-existent orders. The dry-run reference is helpful but the description is otherwise minimal.

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 says 'by id', which clarifies that order_id is the order identifier, but it does not provide format, example, or any validation hints. For a single-parameter tool, the description adds minimal semantic value beyond the field name.

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: cancel an open order, identified by id. It clearly distinguishes the action from placing or viewing orders, and the 'respects dry-run' note adds a unique behavioral qualifier that helps differentiate it from a hypothetical raw cancel.

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 implicitly indicates when to use the tool (when you want to cancel an open order) but does not explicitly mention alternatives or exclusions. There is no guidance on when to use this versus kalshi_cancel_order or other sibling tools. The dry-run mention provides a contextual clue but no direct comparison or condition for choosing 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It states the output includes a score and 'transparent reasons', but it does not disclose any side effects, auth requirements, rate limits, or whether the operation is read-only. It implies a read operation but never explicitly states it. Given the lack of annotations, 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 sentence that is concise and front-loaded with the premium signal label. It conveys the purpose without unnecessary words. It could benefit from a bit more detail on the parameter, but as far as conciseness, it scores well.

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?

While an output schema exists (which might cover return values), the description remains incomplete. It fails to explain the input parameter, any prerequisites, or access constraints (as it's a 'premium signal'). For a tool with one required parameter and zero schema coverage, the description should provide much more context to enable 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 has 0% parameter description coverage, and the lone parameter 'id_or_slug' is completely unexplained in the description. The description mentions 'a market's resolution' but does not clarify what id_or_slug refers to (e.g., is it a market ID or slug format?). The description fails to compensate for the schema's lack of parameter documentation, making it impossible to know how to fill the required field 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's function: it 'scores 0-100 how likely a market's resolution gets contested' and specifically mentions 'UMA dispute risk'. This distinguishes it from sibling tools like get_market or search_markets, which serve different purposes. The verb 'scores' and resource 'market's resolution' are specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or sibling tools. The only contextual hint is 'PREMIUM SIGNAL', which is not a usage guideline. There is no indication of when this should be preferred over other market-related 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?

No annotations are provided, so the description must carry the full behavioral burden. While 'Get' implies a read operation, the description does not explicitly state that it is non-destructive, nor does it disclose any error behavior, rate limits, or side effects. For a read-only tool with zero annotation coverage, this is a significant lack of transparency.

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, precise sentence with no wasted words. The key information (what it gets and how to identify the market) is front-loaded. Perfectly sized for a simple getter.

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

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

Given the tool's simplicity (one parameter) and the presence of an output schema (which covers return values), the description is arguably sufficient to invoke correctly. However, it omits any usage context, edge-case behavior, or relationship to sibling tools, leaving the agent without a clear decision framework. For a tool in a rich ecosystem of similar getters, this is a moderate gap.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that the parameter 'id_or_slug' accepts either a market slug or an ID, which adds meaning beyond the bare schema property label. However, it does not specify how to differentiate slug from ID, format expectations, or behavior when given an invalid value. This is a minimal but real contribution.

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

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

The description clearly states a specific verb ('Get'), resource ('market's details'), and identification method ('by slug (or id)'). It unambiguously distinguishes from search_markets (which lists multiple) and other siblings. No ambiguity about 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?

No guidance is provided on when to use this tool versus alternatives like search_markets or the kalshi_get_market sibling. There is no mention of when-not to use it, nor any differentiation from the similar kalshi_get_market. The agent must infer usage from the name alone.

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. The 'Get' verb and 'live' qualifier together signal a read-only, real-time snapshot operation. It doesn't mention aggregation depth, pagination limits, or invalid-token behavior, but for a simple one-parameter read this conveys the core behavior adequately.

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 12-word sentence that is front-loaded with the core action and scope. Every element — 'live', 'bids/asks', 'CLOB token id' — earns its place, with zero 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 low-complexity tool (one required parameter, no nested objects, plus an output schema that covers return values), the description is nearly sufficient. The main gap is the lack of an explicit differentiation from the sibling kalshi_get_orderbook, though the 'CLOB' qualifier partially handles this. Minor depth/format details aside, an agent has enough to call 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% and the schema only provides the title 'Token Id', so the description must compensate. It adds the key concept that token_id is a 'CLOB' token identifier, which gives meaningful context beyond the schema. However, it omits any format guidance (e.g., numeric string, hex), leaving part of the burden unmet given the 0% coverage.

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

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

The description states a specific verb ('Get'), resource ('live orderbook (bids/asks)'), and scope ('for a CLOB token id'), which fully answers what the tool does. The 'live' qualifier and 'CLOB' framing clearly distinguish it from the sibling price_history and kalshi_get_orderbook, so an agent can tell them apart from the description 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 'CLOB token id' phrasing implies a use context (central-limit-order-book prediction-market tokens) and the 'live' qualifier suggests a real-time snapshot rather than history. However, it never explicitly names an alternative such as kalshi_get_orderbook or states when-not-to-use this tool, leaving the routing decision to inference.

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 only states what the tool returns, not whether it is read-only, the response format, or any constraints (e.g., rate limits, authentication). Minimal transparency beyond the purpose.

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

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

The description is a single concise sentence with no wasted words. It front-loads the core purpose efficiently. However, it is so sparse that it borders on under-specification, but conciseness itself is well-handled.

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 2 parameters, no annotations, and an output schema, the description is incomplete. It lacks usage context, parameter semantics, and behavioral details. The agent cannot fully assess when or how to call this tool based solely on the description.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. The description mentions 'wallet address' which loosely maps to the 'address' parameter, but it does not explain the 'limit' parameter or any default behavior. The description adds virtually no meaning beyond the schema.

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

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

The description states a clear verb+resource: it returns current positions for a wallet address. It is specific enough to understand the core function, but it does not differentiate from sibling tools like kalshi_positions or open_orders, so it loses one point.

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 this tool versus alternatives. No mention of scenarios, limitations, or exclusions. The agent must infer that this is the tool for wallet positions, but no explicit direction is given.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does state a key requirement ('needs the operator's API key'), which is useful context. However, it does not describe the nature of the operation (read-only), potential rate limits, or other behaviors. Since an output schema exists, return format is not needed, but the description could add more about authentication or expected 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?

A single, direct sentence that is front-loaded with the core purpose and the key prerequisite. No wasted words, appropriate for the simplicity of the tool.

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

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

For a parameterless balance-check tool with an output schema present, the description is largely sufficient. It conveys the purpose and the API key requirement. Minor omissions, such as clarifying this is a read-only operation, are not critical 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 tool has zero parameters, so there is nothing to explain. The baseline for 0 parameters is 4, and the description adds no conflict or extra meaning that detracts from 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 description clearly states the resource ('Kalshi account balance') and implies retrieval. It is specific and easily distinguished from sibling tools, none of which directly reference account balance.

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

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

No guidance is given on when to use this tool versus alternatives, nor are any alternatives mentioned. Since the tool is simple and has no parameters, some guidance on prerequisites or typical use cases would be helpful but is 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 provided, the description must carry the burden of behavioral disclosure. It only adds 'respects dry-run,' which is a notable behavioral trait but is not explained—what does respecting dry-run mean for the actual cancellation? It does not mention side effects, error behavior, or whether the operation is reversible. This is minimal and leaves significant ambiguity.

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

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

The description is a single, concise sentence with no wasted words. The action and key qualifier are front-loaded, making it immediately scannable. It is an exemplary model of brevity for a simple operation.

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

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

The tool is simple with one parameter and has an output schema, which covers return-value details. However, the description omits explanation of the dry-run behavior, potential failure modes, or any conditions that might affect execution. Given the complexity is low, a slightly more descriptive note on what 'respects dry-run' entails would improve completeness. As it stands, it is adequate but not thorough.

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 parameter 'order_id' has no description in the schema, and schema description coverage is 0%. The description's phrase 'by id' clarifies that the parameter is the identifier of the order to cancel, which adds minimal semantic value beyond the schema. However, it does not specify any format, constraints, or validation rules. For a single, obvious parameter, this is acceptable but not rich.

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

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

The description clearly states the verb 'Cancel', the resource 'Kalshi order', and the method 'by id'. It fully conveys what the tool does and is specific enough to stand alone, distinguishing it from other operations like placing orders or fetching 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or conditions under which this tool should be chosen over the sibling 'cancel_order'. The parenthetical about dry-run hints at a condition but does not explain it or tie it to usage decisions.

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, and the description is minimal. It does not disclose behavior on missing tickers, error handling, rate limits, or any side effects (though it is clearly a read operation). With no annotations, the description carries the full burden, and it fails to provide meaningful behavioral context beyond the basic action.

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 zero redundancy. It directly states the function and key parameter, making it highly efficient and 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 get-by-ticker operation, the description is adequate but not fully complete. The output schema exists, so return format is covered. However, it lacks information about behavior when the ticker does not exist, pagination, or any authentication requirements. Given the simplicity, the missing pieces are minor, but the lack of any usage or error guidance keeps it at a mid-level score.

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 only parameter, 'ticker', is mentioned in the description ('by ticker'), which adds the context that the tool fetches a single market identified by this string. However, schema description coverage is 0%, so the description does not elaborate on format, examples, or constraints. It compensates minimally by naming the field, but does not add substantial value 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 clearly states the verb 'Get' and the resource 'one Kalshi market by ticker', which precisely identifies the operation. It distinguishes this from search_markets (which searches multiple markets) and get_orderbook (which fetches order book 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?

No guidance is provided on when to use this tool versus alternatives like get_market or kalshi_search_markets. The context of a ticker is implicit, but there is no explicit statement about prerequisites, when to prefer this over search_markets, or when not to use it.

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

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

With no annotations, the description carries the full behavioral burden and discloses the key quirk: 'Kalshi publishes bid ladders only; asks are derived as 1 - NO bid' — revealing that asks are computed, not native — plus 'Raw ladders included' flags that both raw and normalized forms are returned. This is genuinely useful beyond the schema. Minor omissions (auth, error behavior) keep it from a 5. No annotation contradiction.

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

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

Two tight sentences (~25 words) that front-load the purpose then add the essential derivation detail in a parenthetical. Every clause earns its place — including the final 'Raw ladders included,' which conveys a distinct fact. 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 output schema covers return format, so the description need only handle retrieval semantics, and it delivers the critical normalization/derivation quirk. Gaps: no sibling-routing guidance and no depth semantics. Adequate for a 2-param read tool but short of 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?

Schema coverage is 0%, so the description must compensate, and it partly does: the normalization/derivation context clarifies what the ticker's ladder values represent. But it never explicitly defines `depth` (number of ladder levels) or the ticker format, relying on standard naming and the default of 10. Meaningful but incomplete compensation for the coverage gap.

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

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

Description states a clear verb-resource-scope ('Kalshi orderbook for a ticker') and goes further to specify the normalized YES-book bid/ask view. It's concrete and specific. However, it doesn't differentiate from the generic `get_orderbook` sibling in the same tool set, so an agent must rely on the kalshi_ prefix to infer how the two differ.

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

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

No when-to-use or when-not-to-use guidance. With both `get_orderbook` and `price_history` as siblings, the description offers no basis for choosing `kalshi_get_orderbook` over them, and never mentions alternatives or exclusion conditions. The normalization note clarifies data semantics, not tool selection.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only states that trades are 'public', implying read-only access, but does not explicitly confirm no side effects, does not mention rate limits, pagination, or the nature of the returned data. The description is too sparse to inform the agent about important behavioral aspects.

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, which is concise. However, it is under-specified: while it conveys the core purpose, it omits necessary detail about parameters and usage. It is not verbose, but the brevity reduces its utility, making it borderline between adequate conciseness and excessive terseness.

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 presence of an output schema, return format may be defined there, but the description still lacks essential context for calling the tool correctly. It does not clarify the ticker format, the meaning of the limit parameter, or how this tool relates to other market data tools. For a simple tool with two parameters and no schema descriptions, the description is 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?

Input schema coverage is 0%, so the description must explain both parameters. It mentions 'ticker' as a Kalshi ticker but provides no guidance on how to obtain or format it, and it completely omits 'limit' (which has a default of 50 but its effect on the result is unexplained). The description adds minimal value beyond the parameter names.

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

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

The description 'Recent public trades for a Kalshi ticker' clearly indicates the tool retrieves public trade data for a given ticker. It is specific to trades, distinguishing it from siblings like get_orderbook and price_history, though it does not explicitly name alternatives. The lack of a verb is mitigated by the tool name 'kalshi_get_trades', which implies retrieval.

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 usage guidance is provided. The description does not mention when to use this tool versus alternatives such as get_orderbook or price_history, nor does it state any prerequisites like needing a valid ticker from search_markets. An agent would have to infer usage solely from the tool name and description.

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

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

No annotations are provided, so the description must fully disclose behavior. It only mentions the API key requirement, but does not state whether the operation is read-only, the return format, or any side effects. This is a significant gap for a tool with zero annotation coverage.

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 that front-loads the resource and includes the critical API key requirement. It is concise with no fluff, though the brevity comes at the cost of missing necessary 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 tool's simplicity (one parameter), it is still incomplete: it does not describe the output, provide usage context, or mention any constraints beyond the API key. The presence of an output schema helps, but the description alone leaves significant gaps.

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

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

The schema has a single 'limit' parameter with no description, and the tool description provides no additional meaning. With 0% schema description coverage, the description should compensate 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?

Description identifies the resource (Kalshi resting orders) and hints at the operation, but lacks an explicit verb (list, fetch, etc.). It does not distinguish from the sibling tool 'open_orders' which likely serves the same purpose.

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

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

The only usage hint is the API key necessity. No guidance is provided on when to choose this over alternative tools like 'open_orders' or other Kalshi query 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?

Since no annotations are provided, the description carries the full burden. It discloses the critical 'DRY-RUN by default' behavior, preventing accidental real orders, and reveals internal translation to the YES-book bid/ask. However, it does not mention authentication, error handling, or what happens when dry-run is disabled, leaving some gaps.

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

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

The description is four short, focused sentences with no redundancy. It front-loads the core purpose first and adds critical behavioral details concisely. Every sentence contributes value with zero fluff.

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

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

For a 6-parameter tool with 5 required fields, the description lacks essential information on ticker (market identifier format) and count (number of contracts). While dry-run is mentioned, its exact output (simulated order?) is not clarified. An agent cannot reliably construct a correct call without guessing these 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 compensate. It explains outcome (yes/no), action (buy/sell), and price as probability in (0,1), which is essential. But it omits ticker, count, and time_in_force, leaving their meaning and format ambiguous. Partial compensation only.

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 'Place a Kalshi limit order', specifying the verb and resource. It further clarifies the natural-language semantics for outcome and action, distinguishing it from the generic sibling 'place_order' by the Kalshi-specific and translation detail. This makes the tool's purpose unambiguous.

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

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

No explicit guidance on when to use this tool versus alternatives like 'place_order'. The description implies it is for Kalshi orders but does not state exclusions or offer a comparison to the generic 'place_order' sibling. An agent must infer the selection criteria without direct support.

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

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

Since no annotations are given, the description must carry the full burden of behavioral disclosure. It only mentions that the operator's API key is needed, which is a prerequisite, but does not state what the tool actually does (e.g., returns positions), whether it's read-only, or any side effects. This is insufficient.

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

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

The description is extremely short, but this is under-specification rather than conciseness. It lacks essential information and does not earn its place by adding value; it reads more like a placeholder than a complete definition.

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, the description still fails to clarify the tool's purpose and parameters. An agent cannot determine what action to expect or how to use the limit parameter, making the description incomplete for effective use.

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 explain the limit parameter, but it does not. The sole parameter is left undocumented, providing no additional meaning beyond the schema's type and default.

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 'Kalshi positions' is ambiguous; it doesn't specify an action verb like 'list' or 'get' and does not differentiate from sibling tools such as get_positions. It merely names the resource without stating what is done with it.

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 on when to use this tool versus alternatives like get_positions or other kalshi_* tools. The description does not mention any context, preconditions, 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, the description carries the full burden of behavioral disclosure. It clearly states that the tool pages open markets (not all markets), filters on title/ticker, excludes auto-generated MVE combo shards, and that prices are dollar strings rather than cents. These are non-obvious behaviors that materially affect how results should be interpreted. The only gap is that it doesn't mention pagination behavior or how volume filtering works, but the core transparency is above average.

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 concise three sentences, front-loaded with the primary purpose ('Search Kalshi markets'). Each sentence adds new information: the API limitation, the filtering/exclusion behavior, and the price format. There is no redundancy, and the structure is logical and easy to parse.

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 key behavioral quirks (no text search, MVE exclusion, dollar string prices) and an output schema exists, so return details are handled. However, it omits documentation of its own parameters, which are all optional but could each affect results significantly. Additionally, it doesn't differentiate from the sibling 'search_markets', which might be a similar or overlapping tool. This leaves gaps for an agent trying to decide on usage.

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% — the description never mentions 'limit', 'query', or 'min_volume'. It hints that filtering is done on title/ticker, which likely maps to the 'query' parameter, but it does not explicitly confirm this or explain what each parameter does. Given the low coverage, the description should compensate by documenting parameter behavior, but it does not, leaving the agent to guess at 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 states a specific verb ('Search') and resource ('Kalshi markets'), and goes beyond a simple restatement by explaining the lack of a text-search endpoint and the fallback approach of paging and filtering. It also notes the exclusion of auto-generated MVE combo shards, which adds specificity. However, it does not explicitly name sibling alternatives like 'search_markets', so differentiation is implicit rather than 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 context about why this tool exists (Kalshi has no text-search endpoint) and how it operates (pages open markets and filters), which indirectly informs usage. However, it does not explicitly state when to use this tool versus alternatives, such as when a user wants a full-text search or a more efficient lookup. The 'when' is implied but not directly addressed, leaving the agent to infer usage boundaries.

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 only states 'List' without revealing whether this operation is read-only, requires special permissions, or has side effects. The agent has no indication of safety or side effects, which is a significant gap for a trading-related 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 a single, front-loaded sentence that states the action and scope with no filler. It is appropriately concise for a zero-parameter tool, though it might be slightly under-specified when considering behavioral context.

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

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

Given the presence of an output schema and no parameters, the description is minimally sufficient. However, it does not clarify the meaning of 'operator wallet' or distinguish from the similar-sounding sibling 'kalshi_open_orders'. It lacks any extra context that would help an agent decide when this tool is the right choice beyond the literal wording.

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 schema coverage is trivially 100%. Per the rubric, a description for a 0-parameter tool gets a baseline of 4 because there is nothing to explain. The description adds no parameter details, but that is unnecessary here.

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

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

The description states a specific verb ('List') and resource ('open orders') scoped to 'the operator wallet', which is clear and actionable. However, it does not differentiate from the sibling tool 'kalshi_open_orders', which likely serves a similar purpose, so a perfect score is not warranted.

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. Siblings like 'place_order', 'cancel_order', and 'get_positions' exist, but no context is given for selecting this tool. The agent is left to infer usage from the name alone.

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 full behavioral disclosure burden. It states the tool analyzes and reports, implying a read-only operation, but does not explicitly confirm it has no side effects, nor does it disclose potential limitations (e.g., data sufficiency, time windows). The mention of 'fresh panic jumps' and 'historical reversion tendency' adds some context but lacks depth.

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, consisting of a single sentence that front-loads the core purpose. The 'PREMIUM SIGNAL' label is extraneous but does not add bulk. It avoids unnecessary verbosity while conveying the primary function, though it could be tightened further.

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 (so return values need not be described), the description is incomplete for agent usage. It does not explain the parameters, nor does it provide usage context such as when the signal is considered active or how to interpret the reversion tendency. For a tool with four configurable parameters and no schema descriptions, this is a significant 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 description provides zero information about the four parameters (hours, token_id, threshold, lookback_s). With schema description coverage at 0%, the description must compensate, but it does not map any parameter to its role or default behavior. The agent is left to guess what 'hours' or 'threshold' mean based solely on the schema property names, which is insufficient.

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 purpose as an overshoot/fade detector that analyzes a token's recent price series for panic jumps and reports on fade setups and historical reversion tendencies. It uses a specific verb 'analyzes' and names the resource, distinguishing it from raw data tools like price_history. However, it does not explicitly differentiate from siblings beyond implying signal generation.

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 explicit guidance on when to use this tool versus alternatives like price_history or get_market, nor any conditions or exclusions. The description implies it is for fade detection but does not state scenarios where it is appropriate or inappropriate, leaving the agent without clear selection criteria.

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

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

With no annotations provided, the description carries the full burden. It discloses the non-destructive dry-run default, the conditions required for real trading (env vars), the signing of builder code, and the price semantics. This is thorough and goes beyond a simple 'place order' statement, giving agents critical safety and operational 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 extremely concise, two sentences, with the most important information (dry-run default) front-loaded. Every sentence adds value, and there is no wasted text.

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?

While an output schema exists, the description does not compensate for the 0% parameter coverage. It explains dry-run behavior and price but omits essential details about token_id, side, size, and order_type. An agent would struggle to correctly fill all required parameters without additional 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 schema has 0% description coverage, so the description must compensate. It only clarifies the meaning of 'price' (implied probability) but leaves token_id, side, size, and order_type unexplained. This is a significant gap for an agent trying to populate these parameters correctly.

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

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

The description clearly states a specific action ('Place a limit order') and resource (an order). It distinguishes itself from siblings like cancel_order and open_orders simply by being the order-placement tool. The added detail about dry-run behavior further sharpens its purpose.

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

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

The description provides clear guidance on when to use it in dry-run mode versus real trading, explicitly requiring environment variables for live execution. It does not explicitly mention alternative tools, but since this is the only order-placement tool among the siblings (kalshi_place_order is for a different platform), the context is sufficient.

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

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

With no annotations, the description carries full behavioral disclosure duty, but it only states the purpose and parameters. It does not mention read-only nature, return format, pagination, rate limits, or any side effects. For a data retrieval tool, some behavioral context is missing.

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, well-structured sentence that front-loads the core purpose and parameter semantics. No fluff or redundancy, making it easy for an agent to quickly grasp the tool's function.

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

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

Given the tool's simplicity (3 parameters, no schema descriptions), the description covers the essential parameter meanings. However, it omits behavioral aspects like read-only nature and any limitations, which would be expected in a fully complete definition. The presence of an output schema mitigates the need to describe return values.

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 explicitly explains the meaning of the key parameters: 'hours back' maps to hours, and 'fidelity_minutes resolution' maps to fidelity_minutes. With schema coverage at 0%, this inline clarification significantly compensates for the lack of parameter descriptions in 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 clearly states it returns recent price history for a CLOB token, with parameters for time window and resolution. It uses a specific resource ('CLOB token id') and implies a retrieval action, making its purpose clear. However, it does not explicitly differentiate from sibling tools like get_market or get_orderbook, which could offer price-related data.

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

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

No guidance is provided on when to use this tool versus alternatives like get_market, get_orderbook, or historical data tools. The description only states what the tool does without indicating suitable 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the underlying API and lists return fields (token ids, prices, metrics, resolution info), but it does not mention whether the operation is read-only, requires authentication, or has any side effects. For a search tool this is likely safe, but the absence of explicit safety cues keeps it at a middling score.

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

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

The description is two sentences with no filler. The primary purpose is front-loaded, and each clause adds value: the search action, the underlying API, the empty-query behavior, and the return fields. There is no redundancy or extraneous 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?

Given the output schema exists, return values are adequately covered. The description explains the essential behavior (text search and empty-query listing) and the underlying API. It does not clarify the effect of 'limit' or pagination/sorting, but these are minor for a simple 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 compensate. It adds meaning for the 'query' parameter (text search and empty-query behavior) but provides no information about 'limit' beyond its existence in the schema. Partial compensation is insufficient for a fully undocumented parameter set.

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: 'Search Polymarket markets by text' with a distinct resource (Polymarket markets) and mentions the underlying API (Gamma public-search). It differentiates from siblings by naming the platform, distinguishing it from kalshi_search_markets.

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 text-based searching and explicitly notes that an empty query lists open markets, which is a key behavior for selecting this tool. However, it doesn't explicitly contrast with alternatives like get_market or kalshi_search_markets, though the platform name inherently routes the agent.

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 states the tool returns status information, which strongly implies a read-only operation with no side effects. However, it does not explicitly declare 'read-only' or mention any potential effects. The listed return content (dry-run, attribution, capabilities) makes the informational nature clear, so 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 one tightly packed sentence that lists the key return categories without any filler. It is front-loaded with the core concept ('Server status') and then specifies details. 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?

The tool has an output schema (not shown here, but referenced as existing), which likely defines the exact return fields. The description covers the three main aspects, but does not elaborate on what 'capabilities' means or how they are listed. Given the output schema fills in details, this is reasonably complete, though a touch more context (e.g., 'capabilities such as X, Y') would elevate it.

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 are no parameter semantics to explain. The description correctly does not attempt to describe params. With no parameters, the schema is trivially complete, and the description adds no unnecessary clutter.

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 reports server status and enumerates three specific aspects: dry-run state, attribution config, and enabled capabilities. It uses a noun phrase but the purpose is unambiguous. It differentiates from siblings like get_market or place_order by focusing on server internals rather than market or trading operations.

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

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

The description implies the tool is for checking server configuration, but it does not explicitly state when to use it (e.g., before placing orders to verify dry-run mode) or exclude scenarios where other tools are more appropriate. Since it's a status tool, the usage context is somewhat obvious, but explicit guidance would improve clarity.

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