dMoERA Creator

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 discloses the main side effects: deploying capital according to weights and risk caps, and pausing the main platform router. It does not cover edge cases such as repeated activation or failure conditions, so it stops short of full 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?

The description is compact and well-structured: a one-line purpose, a short behavior paragraph, and an Args/Returns section. Every sentence contributes meaningful information, and the core action is front-loaded for quick scanning.

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 action with an output schema, the description covers the purpose, key behavior, side effect, and argument. It could mention deactivation or prerequisites, but those are reasonably inferable from the sibling tool list and the simplicity of the API surface.

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

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

The only parameter is fund_id. The description says 'The fund's ID,' which is minimal and largely repeats what the property name already implies. Since schema description coverage is 0%, this is adequate but not enriching; it provides no additional constraints, format guidance, or provenance for the ID.

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 action ('Activate Manager Mode for a fund') and resource, then clarifies the mechanism ('starts the personal router'). It further differentiates itself by describing unique behavior: deploying capital across roster bots and pausing the main platform router, making it clearly distinct from siblings like deactivate_fund or get_active_fund.

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

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

It gives clear context for when the tool should be used: when Manager Mode should be activated for a fund. It also implicitly warns that the main platform router is paused while active, which is a relevant consideration for choosing this tool. It does not explicitly name alternatives or preconditions, but the purpose is unambiguous for a single-action tool.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It states that the operation adds to the roster, mentions the personal-fund ownership restriction, documents a default weight, and says it returns the updated roster entry. However, it does not disclose what happens if the bot already exists in the roster, whether weights are rebalanced, or whether the fund must be in a particular state to accept changes.

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

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

The description is well-structured: a one-line purpose, a key constraint, a cross-reference to list_my_bots, an args list that mirrors the schema, and a return-value note. Every sentence adds value and the most important usage constraint 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?

Given the output schema exists, the description need not detail the return shape. It covers the operation, eligibility prerequisites, the personal-fund restriction, all parameters, and the return value. It could optionally warn about weight-sum constraints or duplicate bots, but the core information needed to invoke the tool correctly is present.

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

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

Schema coverage is 0%, so the description must fully document the parameters, and it does: fund_id, bot_id, bot_domain, and weight each receive meaningful explanations. Examples like 'momentum_eth_v3' and 'eth_usdc', plus the explicit 'initial allocation weight in percent (default 20.0)', add significant value beyond the bare schema names and types.

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 'Add a bot to a fund's roster', which is a specific verb+resource statement that clearly identifies the action. It distinguishes itself from sibling tools like remove_bot_from_fund and swap_bot_in_fund by focusing on the add-to-roster operation, and the constraint about personal funds adds further precision.

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

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

The description gives explicit context for when to use this tool: adding a bot to a fund's roster, and notes that personal funds can only contain the authenticated user's own bots. It also directs the agent to list_my_bots to see eligible strategies, providing a concrete prerequisite check. It does not explicitly contrast with swap_bot_in_fund or update_fund_weights, but the usage context 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?

With no annotations, the description carries the full burden and discloses key side effects: irreversibility, capital return, and preservation of the performance record for copy-trader settlement. It also states the return format. It does not mention prerequisites like whether the fund must be active, but the provided behavioral context is substantial.

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

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

The description is compact and well-structured, with the core action and irreversible consequence front-loaded. Each sentence serves a distinct purpose—action, effect, warning, side effect, parameter, and return—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?

For a single-parameter destructive tool with an output schema, the description covers the essential effects and return value. However, it omits whether the fund must be active and what happens to associated bots or strategies, which could be relevant for an agent deciding to call it. Overall, it is nearly 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, but 'fund_id: The fund's ID' is tautological and adds no meaning beyond the schema's title. It does not explain where the ID comes from, how to validate it, or any format expectations, leaving the agent without useful parameter 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 states a specific action ('Permanently close a hedge fund') with a clear resource, and the word 'permanently' distinguishes it from sibling deactivate_fund. It also adds a concrete consequence ('Returns all capital to the wallet'), making the tool's scope unmistakable.

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

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

The irreversibility warning and 'permanently' imply that this tool is for final closure, not temporary deactivation. However, it never explicitly names alternatives like deactivate_fund or states when not to use this tool, leaving the agent to infer the decision from the word 'permanently'.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses the inactive initial state, the wallet_cash deduction at creation, and the restriction that personal funds can only contain the user's own bots. It lacks some details like error conditions, but covers the most important behavioral traits.

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, then briefly covers behavioral constraintsaic, then enumerates parameters in a compact list. Every sentence adds value, and the Args block is neatly structured 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?

Given the tool's complexityhra, the description covers prerequisites (wallet_cash, eligible bots), post-creation steps (activate_fund), parameter constraints, and return value. The presence of an output schema means the return-object explanation is sufficient, and no critical context appears 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 input schema has 0% description coverage, but the description fully compensates by documenting every parameter: fund_name as display name, router_preset with its four allowed values, aggression_mode with its two values, and philosophy with optionality and max length. This is more semantic detail than typical schema descriptions provide.

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

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

States a specific verb ('Create') and resource ('personal hedge fund') scoped to 'the authenticated user', immediately distinguishing it from sibling fund-related tools like activate_fund and close_fund. The description clearly identifies what the tool produces.

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 contextual guidance: the fund starts inactive and requires activate_fund for Manager Mode, initial capital comes from wallet_cash, and eligible bots are found via list_my_bots. It doesn't explicitly state when not to use this tool or name alternatives, but the guidance is actionable and distinct.

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

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

The description explicitly discloses the major side effects: 'Closes all roster bot positions and returns capital to the wallet,' which is significant for a mutation tool. It does not mention reversibility, preconditions, or failure modes, and with no annotations provided the description carries the full disclosure burden yet only partially meets it.

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 efficiently structured: a one-line summary, then the behavioral effect, then minimal Args and Returns lines. It is free of bloat and front-loads the key action and side effects. The Args line is redundant but harmless, and the overall length is appropriate.

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 mutation tool with no annotations and 0% schema coverage, the description omits prerequisites, reversibility, error conditions, and parameter provenance. It covers the main action and side effects but leaves an agent without enough information to use the tool safely and correctly, such as whether the fund can be reactivated or what happens to fund state.

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 'fund_id: The fund's ID,' which merely restates the parameter name and title without adding semantic content. At 0% schema description coverage, this is a weak compensation attempt that fails to explain the parameter's format, source, constraints, or relationship to other fund operations.

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

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

The description states a clear action ('Deactivate Manager Mode') and its primary effect ('Closes all roster bot positions and returns capital to the wallet'). The verb, resource, and behavioral outcome are specific enough to distinguish it from activate_fund and most siblings. However, it doesn't explicitly differentiate from close_fund, and 'returns to the main platform router' is ambiguous without more context.

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

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

No when-to-use guidance is provided; the description never states prerequisites (e.g., the fund must be in manager mode), conditions, or how this differs from close_fund. An agent cannot determine from the description alone when to invoke this tool versus a sibling. The 'Args' and 'Returns' lines are present but add no decision 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 available, the description carries the full behavioral burden. It discloses that this is an estimation step, explains what the cost represents (winding down old positions and opening new ones), and specifies the return unit: estimated friction in bps of fund AUM. It does not explicitly state that no mutation occurs, but the 'estimate' framing and the 'before calling swap_bot_in_fund' context make this adequately 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 compact and well-organized: a one-sentence summary, a usage directive, an Args list, and a return explanation. No extra fluff or repetition of schema types is included, and every sentence serves a purpose.

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

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

For a tool with four simple and required parameters, the description covers its main purpose, when to use it, what the result means, and the return unit. Minor gaps remain, such as not explaining where to find valid new_bot_domain values or any prerequisites (e.g., whether the fund must be active), but the core invocation context is sufficiently clear.

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

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

Schema description coverage is 0%, so the Args section is essential. It adds meaning for three of the four parameters: old_bot_id is 'the bot being considered for removal', new_bot_id is 'the replacement bot', and new_bot_domain is 'the replacement bot's doman'. Only fund_id ('The fund's ID') merely restates the schema title, but the other parameters are meaningfully clarified.

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: 'Estimate the friction cost (in bps) of swapping a bot in a fund.' It clearly distinguishes this estimation tool from the actual mutation tool, swap_bot_in_fund, by naming the operation and 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 explicitly says 'Use this before calling swap_bot_in_fund' and explains why it should be used: to understand the cost of winding down the old bot's positions and opening new ones. This is a clear when-to-use directive tied to a specific sibling 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 full burden of disclosing behavior. It clearly states 'immutable once saved', which is critical behavioral context—an agent knows a save can't be undone. It also states the function returns the generated card. However, it does not disclose whether generation overwrites, requires approval, or has side effects on fund state beyond immutability; still, for a single-arg generator, the main side-effect (immutable creation) is 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 compact and front-loaded: the first sentence conveys the action and the immutable constraint. The Args line is redundant with the schema but serves as a quick reference. There is no wasted prose; every sentence adds value.

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 a single-parameter tool with an output schema, the description covers the critical behavior (immutable save) and return. It doesn't explain why the card is immutable or what grades/analysis entail, but the output schema presumably fills in the return structure. For a simple generator tool, this is nearly complete; the only missing piece is when to invoke it over alternatives, but that falls under usage guidelines.

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 one parameter and is 0% documented, meaning the schema provides no description for 'fund_id'. The description does repeat 'fund_id: The fund's ID' in the docstring, which adds minimal meaning beyond the schema (type integer). It doesn't specify where to find the ID or validation constraints. Baseline for 1 param with 0% coverage would be low, but the description at least identifies it; however it adds no semantic depth beyond the docstring.

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 ('Generate'), resource ('fund report card'), and a key distinguishing constraint ('immutable once saved'). This clearly differentiates it from the sibling get_fund_report_card (which retrieves an existing card) and other fund-related actions.

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 purpose is clear but there is no explicit guidance on when to generate a new card vs. using the existing get_fund_report_card, nor are there prerequisites or consequences stated. The immutability note implies a caution but doesn't state 'use get_fund_report_card to retrieve the existing one' or warn that regenerating is impossible.

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 disclosure burden. It clearly discloses the key behavioral trait: returns the active fund object or null if Manager Mode is not active. The 'authenticated user's' phrasing and read-style verb make the operation seem safe, though it does not explicitly state that no side effects occur.

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, purposeful sentences: the first names the resource, the second states the return contract. No filler, no restatement of the tool name, and the most important distinguishing detail ('Manager Mode') 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 zero-parameter getter with an output schema, the description is nearly complete: it identifies whose fund, the Manager Mode condition, and the null behavior. It could optionally mention activate_fund/deactivate_fund for mode management, but that is not needed to invoke this tool correctly.

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

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

There are zero parameters, so the schema is already complete and there is nothing for the description to clarify. The zero-parameter baseline of 4 applies.

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

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

The description states a precise verb ('Get') and a scoped resource ('authenticated user's currently active (Manager Mode) fund'), which clearly separates this from generic getters like get_fund and list_funds. The explicit null-return condition further defines what the 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 when to use the tool—when the caller needs the current Manager Mode fund—and the null condition conveys when no active fund exists. However, it does not name alternatives or say when to use get_fund/list_funds instead, so the guidance is inferred rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the complete return payload (performance metrics, position, trade history) and conveys read-only intent via 'Get', which is adequate for a non-destructive lookup. It does not mention error behavior when bot_id is unknown, but that is a minor gap for a simple get 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 purpose is front-loaded in the first sentence, followed by a compact Args/Returns structure. The return-field enumeration is partially redundant with the existing output schema but remains readable and serves as a quick-reference without bloating the 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?

Given the tool's low complexity (one required parameter) and the presence of an output schema, the description covers the essentials: operation, parameter semantics, and return content. The only omission is routing guidance against siblings like list_bots/get_strategy_report, which is already accounted for under usage_guidelines.

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 this dimension falls entirely on the description. The Args section explains bot_id ('The bot identifier') and gives a concrete example ('Eth_Full_Ensemble'), compensating well for the bare schema; it stops short of saying where the identifier comes from (e.g., list_bots).

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?

Opens with a specific verb+resource ('Get detailed profile and performance stats for a specific bot'), making the operation and target unambiguous. The 'specific bot' phrasing distinguishes it from the list-oriented sibling list_bots, and the output list clarifies scope versus analytics siblings like get_strategy_report.

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 its use case — query a known bot by ID — but never states when to choose it over alternatives such as list_bots or get_strategy_report, and names no exclusions. Usage context must be inferred from the word 'specific', so a less experienced agent gets no explicit routing help.

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 disclosure burden; it covers output shape (JSON with price, bid, ask, source, change_24h_pct, volume_24h), the macro scope (all tracked symbols), and sources (Binance/Coinbase/Kraken). It does not mention auth requirements or potential rate limits, but for a read-only getter this is a minor gap.

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

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

Two compact sentences front-load the main action and follow with a structured return description. No filler or redundant schema 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 parameterless price tool, the description is complete: it defines the exact symbols, exchanges, and return shape. The presence of an output schema further covers the response details, leaving an agent with everything needed to 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 has zero properties and 100% description coverage by default, so the baseline of 4 applies; the description adds value by explaining what data is returned for the fixed symbol set. There are no parameters to clarify.

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 precise verb ('Get') and a specific resource ('current live prices for all tracked symbols'), then enumerates the exact tracked symbols (ETHUSDT, BTCUSDT, SOLUSDT) and data sources. This clearly differentiates the tool from the fund/bot/strategy siblings.

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

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

The description makes the tool's use case self-evident—fetching live market prices—and no sibling tool appears to offer price retrieval, so there is no ambiguity about when to choose it. It does not explicitly contrast it with alternatives, but it provides clear context and no 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 explains the two statuses ('live' vs 'planned'), states what can be required, and lists the exact returned fields. It does not mention potential side effects, but the verb 'List' and the catalog nature make read-only behavior reasonably clear.

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

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

The description is well-structured and front-loaded: the first sentence states the core purpose, the second clarifies usage context, the third defines status semantics, and the fourth covers the return shape. Every sentence adds value and there is 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?

For a zero-parameter catalog-listing tool, the description is complete. It explains the domain context, the status logic that affects usage, and the return structure in enough detail. Since an output schema exists, the description does not need to separately document each return field's deeper 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?

The tool has zero parameters, so the baseline of 4 applies. The description adds no parameter-specific information because there are none to document, and the schema already indicates that no arguments are required.

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 names the resource ('all data feeds available to strategies via ctx.features'), making the tool's purpose immediately clear. It also explains how features relate to strategy execution and required_features, distinguishing it from sibling tools that handle funds, strategies, or prices.

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 this tool: it lists available data feeds and clarifies that only 'live' features can be used in required_features. It does not explicitly name alternative tools that would be preferred in other scenarios, but no direct alternative is evident among the siblings, and the usage context is strong.

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 disclosure. It does state the return shape (JSON with fund details and active roster entries including specific fields), which is useful. However, it does not mention error behavior, access requirements, or whether only active funds can be queried.

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-loads the main purpose, and uses a clear Args/Returns structure. Every sentence adds meaningful information 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?

For a simple lookup tool with one parameter and an output schema, the description is mostly complete. It names the returned roster fields and the input, but lacks explicit sibling differentiation and edge-case behavior, leaving a small 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?

There is only one parameter and the schema provides no description, so the description must clarify it. Saying 'fund_id: The fund's ID' adds a minimal semantic pointer, but it is largely tautological and does not explain where the ID comes from or how it is used.

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

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

The description states a specific verb and resource: 'Get detailed info for a specific hedge fund, including its roster.' It clearly distinguishes this from listing tools like list_funds by emphasizing 'specific' and by naming the roster contents.

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

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

The description implies usage: call this when you need details for one fund and have a fund_id. It does not explicitly compare against siblings such as list_funds or get_active_fund, nor does it state when not to use it, so guidance is only implied.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state 'real-time' and enumerates the returned analytics categories, which adds some behavioral context, but it does not mention authentication needs, error conditions, data currency limits, or side effects (though the 'Get' verb suggests read-only 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 short and front-loaded with the main purpose, followed by a useful return summary. The Args line is redundant with the schema and the phrase 'fund analytics' appears twice, but overall the structure is clean and economical.

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

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

For a one-parameter read tool with an output schema, the description gives a reasonable outline of returned data. However, the lack of usage guidance relative to the broad sibling set and the absence of behavioral caveats leave noticeable gaps for correct 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?

Schema description coverage is 0% with one required parameter, so the description must compensate. It only says 'fund_id: The fund's ID,' which is essentially a tautology that adds no meaning beyond the schema's integer type and property 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 uses a clear verb and resource: 'Get real-time analytics for a fund dashboard,' and lists specific content categories (allocation breakdown, per-bot performance, risk metrics, benchmark comparison). It does not explicitly contrast itself with siblings like get_fund_performance or get_fund_live_pnl, but the listed contents make its scope reasonably identifiable.

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

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

There is no guidance on when to use this tool versus the many similar fund-related siblings. The phrase 'for a fund dashboard' implies a use case, but no alternatives or exclusions are provided, leaving an agent to guess which analytics tool fits.

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. It adds meaningful behavior: 'real-time', 'closed positions' as the source, and a JSON series of cumulative PnL points as the output. However, it does not say whether the operation is read-only, how freshness is defined, or whether it aggregates over all time, leaving behavioral uncertainty.

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 and a clear return-type line. The Args block is redundant with the input schema, but it is short enough not to be a real cost.

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

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

For a single-parameter tool with an output schema, the core contract is mostly covered: what it does, its data source, and its return shape. The main gap is contextual: no guidance on selecting this tool over related fund analytics/performance tools, which an agent needs when choosing among the sibling list.

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 was responsible for explaining fund_id, but it only says 'The fund's ID', which merely restates the property name and the schema's title 'Fund Id'. It does not say where to obtain the ID, what format to use, or what kinds of IDs are valid.

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 deliverable ('real-time PnL chart'), a data source ('closed positions'), and a scope ('a fund's roster'), so an agent can tell it apart from generic fund history tools. It does not explicitly contrast with sibling tools like get_fund_performance or get_fund_analytics, so it stops short of a 5.

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

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

There is no 'when to use' guidance, no exclusions, and no mention of alternatives. The description only states what it builds and its return type; the agent must infer when this is the right tool among the many get_fund_* siblings.

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

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

With no annotations provided, the description carries the full burden and does disclose the return format ('Returns a JSON time-series of AUM/PnL snapshots') and the capping behavior of limit ('Max snapshots to return'). However, it omits the time-series ordering, pagination behavior, and error handling for invalid fund_id, which matter 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?

Five compact lines that front-load the core purpose, then list parameters and return shape without fluff. The Args section partially duplicates schema titles and the default-100 value, but the added limit semantics earn their 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 2-parameter, 1-required tool with an output schema, the description covers purpose, parameter semantics, and return shape adequately. The notable gaps are time-series ordering and how to fetch beyond the 100-snapshot cap, both relevant to the stated P&L-graph use case.

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

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

Schema description coverage is 0%, so the description must compensate. It does add real meaning to limit ('Max snapshots to return'), but 'fund_id: The fund's ID' merely restates the schema's 'Fund Id' title with no format, validation, or lookup semantics. Compensation is only partial.

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 performance snapshots for a fund's P&L graph,' with the return format clarified as 'a JSON time-series of AUM/PnL snapshots.' It does not explicitly distinguish itself from similar siblings like get_fund_live_pnl or get_fund_analytics, leaving the differentiation to inference.

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

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

No guidance is given for when to use this tool versus the many similar fund-data siblings (get_fund_live_pnl, get_fund_analytics, get_fund_trades, etc.) in the sibling list. There are no usage conditions, exclusions, or alternative routing clues, so an agent must guess based on name similarity 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, the description carries the behavioral transparency burden. It discloses the return format as a JSON array with entry/exit prices and PnL, and 'Get' implies a read operation, but it does not mention empty results, authorization needs, or whether pending orders are included.

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 three short lines with no filler. The Args block is appropriately placed, and every sentence carries useful information.

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

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

For a one-parameter read operation with an output schema present, the description is largely sufficient: it names the input and the return contract. It misses only optional niceties like empty-fund behavior or explicit sibling differentiation.

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 Args block identifies fund_id as 'The fund's ID,' which adds only marginal meaning beyond the schema's title 'Fund Id.' It is sufficient for a single trivial parameter, but no additional context about format, source, or requiredness is provided.

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 'Get open positions for a fund's roster bots,' specifying both the action and the resource. The phrase 'open positions' distinguishes it from related trade and PnL tools, though it does not explicitly name an alternative.

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

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

There is no guidance on when to use this tool versus siblings such as get_fund_trades, get_fund_live_pnl, or list_bots. The intended usage is only implied by the verb 'Get,' with no exclusions or alternative routing provided.

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

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

With no annotations, the description carries the full burden. It discloses that the report card is immutable and that null is returned if none exists, which is useful. However, it does not explicitly state that the operation is read-only, whether any permissions are required, or how errors are surfaced. The disclosure is adequate but minimal for a getter.

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, a brief Args section, and a return behavior statement. Every sentence adds value, and the key information is front-loaded at the start. 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 single-parameter getter with an output schema present, the description covers the essential edge case (null when no report card exists) and the immutable nature of the returned data. It does not need to detail return values since the output schema exists. Minor gaps like relationship to generate_fund_report_card fall under usage guidance, not completeness. Overall it is sufficient 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 must compensate. It restates 'fund_id: The fund's ID', which adds little beyond the parameter name and type from the schema. It does not explain how to obtain a valid fund_id, constraints on the integer, or the relationship to other fund-related tools. The compensation 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?

States the specific verb 'Get', the resource 'report card', and qualifiers 'latest' and 'for a fund'. This clearly distinguishes it from sibling tools like generate_fund_report_card, get_fund, and get_fund_analytics. The mention of 'immutable' and 'null if none exists' adds precision to the purpose.

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

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

Provides no guidance on when to use this tool versus alternatives. It does not mention that generate_fund_report_card should be used when no card exists, nor does it note any conditions for using get_fund or get_fund_analytics instead. The agent is left to infer usage from the name and sibling list.

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

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

With no annotations provided, the description must disclose behavioral traits. It states that the tool returns a JSON array of closed trades, which provides some transparency about the output. However, it does not mention any side effects, error handling, ordering guarantees, or rate limits. For a read-only operation this is acceptable but not thorough, meriting a 3.

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 succinct and well-organized: a one-line purpose, then a compact parameter list, then a return type. Every sentence serves a purpose with no fluff. The key information is front-loaded, making it easy for an agent to parse quickly.

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

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

The tool is a simple paginated list; the description explains the resource (closed trades for a fund), parameters, and return type. Since an output schema exists, the description need not detail the return structure beyond stating it is a JSON array. No obvious missing context for a straightforward read operation, though it could mention default pagination behavior or ordering, which is not specified.

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 types and defaults with no descriptions (coverage 0%). The description compensates by explaining each parameter: fund_id is the fund's ID, limit is max trades (default 50), offset is pagination offset. This adds meaningful semantics beyond the schema and fully covers all parameters, so 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 clearly states the action: 'Get closed trade history for a fund's roster bots.' This is a specific verb-resource combination that distinguishes it from sibling tools like get_fund_positions or get_fund_analytics. The tool's scope is precise, leaving no ambiguity about what data it retrieves.

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 this tool (when you need closed trades for a fund) but does not explicitly mention alternatives or when not to use it. There is no contrast with similar get_* tools, so the agent must infer the appropriate context. This is adequate but leaves room for explicit routing guidance.

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

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

With no annotations, the description carries the behavioral burden. It clearly indicates a read-only listing operation and reveals that returned stats are 'cached,' which is an important behavioral nuance. It stops short of mentioning rate limits or auth requirements, but for a list 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 well-structured with a clear purpose line, an Args block, and a Returns block. Every sentence adds value, and the parameter details are concise and directly usable by an agent.

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

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

For a simple read-only listing tool, the description covers all invocation details: optional parameters, valid values, defaults, and the return shape. The explicit mention of cached stats adds useful context beyond the output schema, making the definition effectively 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%, so the description must fully explain the parameters, and it does. It gives the domain format with an example, enumerates valid sort values, and specifies limit defaults and maximum. This is strong compensation for the schema 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?

The description starts with 'List bots published to the marketplace,' which clearly identifies the verb, resource, and scope. It does not explicitly distinguish from sibling tools like list_bots or browse_fund_marketplace, but the 'marketplace' qualifier provides enough specificity for basic 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?

The description implies this tool is for viewing marketplace bots, and the parameter guidance (e.g., 'Omit for all domains') is useful. However, it never states when to prefer this over list_bots or browse_fund_marketplace, nor does it provide when-not-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?

No annotations are provided, so the description carries the full burden. 'Get' implies a read-only operation, and the description covers output contents well, but it does not disclose whether the data is live or cached, whether authentication or initialization is required, or any other behavioral caveats. Acceptable for a zero-parameter getter but not thorough.

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 purpose. Each subsequent line adds interpretive value, whether listing output fields or mapping regime values to allowed trade directions. No wasted words.

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 parameters, an output schema, and a simple read operation, the description covers the core semantics and return-value interpretation. The missing piece is an explicit statement of when to call it (e.g., 'call this before opening any position'), though the regime rule lines imply that timing.

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 schema trivially covers everything and the description has no parameter information to add. Baseline 4 applies.

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

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

States a specific verb ('Get'), a clear resource ('current market regime classification'), and enumerates the exact returned data (aggregate/per-symbol regimes, crisis score, and derivatives data). The regime semantics further separate it from the unrelated sibling trading/fund management 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 does not explicitly name alternatives or when-not-to-use this tool. However, the line 'Regime determines which trade directions are allowed' implies it should be consulted before trading, so usage is conveyed through implication rather than explicit guidance.

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

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

With no annotations, the description carries the full burden. It discloses useful behavioral details: the report includes validation runs for all 7 stages, performance metrics, and the integrity block (code hash, AST hash, parameter fingerprint), and notes that it returns the latest validation runs. This goes beyond the tool name and schema, though it does not explicitly mention side effects or failure modes.

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: opening purpose statement, content details, explicit Args line, and Returns line. Each sentence adds distinct information with no fluff or repetition, 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 tool has one required parameter, an output schema that can describe return values, and no nested objects. The description covers purpose, content, and parameter semantics completely enough for correct invocation. Any missing usage guidance is captured in the usage dimension, not a completeness gap 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 description coverage is 0%, but the description explains the sole parameter, strategy_id, as 'The strategy's database ID.' This adds semantic meaning beyond the raw integer type in the schema. It lacks extra guidance on where to find the ID, but for a single simple parameter it provides adequate meaning.

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

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

The description states a specific verb ('Get') and resource ('detailed report card for a strategy'), and elaborates with concrete contents: validation run results for all 7 stages, performance metrics, and an integrity block. This clearly distinguishes it from sibling tools like delist_strategy or sandbox_backtest, as it is specifically a reporting/read tool for strategy status and health.

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: whenever an agent needs a detailed report card for a strategy, including validation and metrics. However, it does not explicitly state when not to use it or mention alternatives from the sibling list, leaving selection conditions 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 behavioral burden. It discloses the return structure and notable context about tournament cadence and scoring weights. It does not mention read-only guarantees or data freshness, but 'Get' and the absence of side-effect language make the behavior adequately 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?

Three short sentences with no fluff. The primary action is front-loaded, and the additional tournament scoring context is directly relevant to interpreting the results. Every sentence earns its place.

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

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

For a zero-parameter read-only status tool with an output schema available, the description is complete. It explains what data is returned, the tournament mechanics, and the scoring formula, giving the agent enough context to invoke the tool and interpret results 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 zero parameters, so the baseline is 4 by the rubric. The description correctly focuses entirely on return semantics rather than parameters, and no parameter clarification is needed.

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 starts with a specific verb and resource: 'Get current tournament round status and leaderboard.' It clearly differentiates from sibling tools like get_market_regime or get_strategy_report because no other sibling is focused on tournaments.

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 this tool by defining what it returns and how tournaments work. It lacks an explicit 'use this instead of X' statement, but since no sibling covers tournament status, the usage context is sufficiently clear.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the operation is a read-only retrieval and that the response is a JSON array of past transitions with timestamps. It does not mention ordering, time range, pagination, or how an empty history is represented, but it still gives a reasonable picture of the 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 two concise sentences with no filler. The first sentence states the action and resource, and the second states the return shape and key field. Every sentence earns its place.

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

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

For a no-parameter getter, the description covers the essential information: what action is performed and what the response contains. Since an output schema exists, the context signal indicates return values are further specified elsewhere, so the missing details like ordering and time span are minor 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 input schema is an empty object, so there are no parameter semantics to document. The description adds no parameter detail, but none is needed; the 0-parameter baseline applies.

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

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

The description uses a specific verb ('Get') and names the exact resource ('the Vault's regime switch history'), making the tool's purpose clear. The second sentence confirms the output type. It doesn't explicitly contrast with sibling tools like get_vault_status or get_market_regime, but 'history' makes the intended scope evident.

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 the Vault's historical regime transitions are needed. However, it provides no explicit when-not-to-use guidance or alternative routing to get_vault_status/get_market_regime, leaving the agent to infer the distinction from the name and context.

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

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

With no annotations, the description carries the behavioral burden. It explains the Vault's rotation behavior and states that the tool returns current regime, allocation weights, and sleeve holdings. The verbs 'Get' and 'Returns' imply a non-mutating read operation, and no side effects are suggested, though an explicit read-only note would have been more 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 three sentences with no filler. The first sentence states the operation, the second explains the Vault concept needed to understand 'regime-aware,' and the third lists the returned fields. Every sentence earns its place.

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

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

For a zero-parameter, read-only status endpoint, the description is complete: it identifies the subject (authenticated user's Vault), explains the domain concept, and enumerates the output. An output schema exists, so return details are covered structurally, and no critical operational guidance 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, and the schema is trivially 100% covered. The description adds context about the Vault's behavior but does not need to elaborate on parameters since there are none. Baseline for zero-parameter tools is 4.

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

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

The description uses a specific verb and resource: 'Get the authenticated user's Vault state.' It explains what the Vault is (a regime-aware allocator) and enumerates the return values (current regime, allocation weights, sleeve holdings), which clearly differentiates it from siblings like get_vault_history or get_market_regime.

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 establishes use for checking current Vault status by emphasizing 'current regime' and 'Vault state.' It does not explicitly name alternatives or state when not to use it, but the temporal framing makes the intended context unambiguous.

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

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

With no annotations provided, the description compensates by disclosing the ranking behavior, the return as a JSON array with a specific list of fields, and the default/max behavior for limit. It does not mention authorization, pagination beyond the limit, or whether results are restricted to certain bot statuses, but coverage is solid for a read-only list operation.

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

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

The description is efficiently organized: a one-sentence purpose followed by clear Args and Returns sections. Every sentence contributes useful information without redundancy or filler.

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

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

The description covers parameters, return fields, default behavior, and ranking, which is sufficient for an agent to call the tool correctly. It lacks only explicit routing against sibling tools, which is more of a usage-guideline gap than a completeness one, and no output schema is provided so the listed return fields are the only 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?

Schema description coverage is 0%, and the description fully compensates by explaining the domain parameter with examples and omission behavior, and the limit parameter with default and maximum values. This adds meaning far 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 the tool lists trading bots ranked by performance, which identifies the specific verb, resource, and ranking criterion. It is distinct enough from siblings like list_strategies, but it does not explicitly name overlapping siblings like get_marketplace_bots or get_open_source_leaderboard to differentiate 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?

The description explains parameter usage (domain filter, limit) but gives no guidance on when to use this tool versus alternatives. No sibling tools are mentioned, and there is no explicit when-to-use or when-not-to-use context, leaving the agent to infer the appropriate choice.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It clearly states that the tool returns a JSON array of domain objects and enumerates the exact fields, which is strong transparency for a read-only listing operation. It does not mention authentication, rate limits, or pagination, but those are less critical for a parameterless list endpoint.

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-organized: a one-sentence purpose, a two-sentence domain primer, and a one-sentence return contract. Every sentence earns its place, 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?

For a parameterless listing tool with an output schema, the description is complete. It defines what a domain is, why it matters (strategies must declare one), and precisely what the response contains. There are no parameters to document and no significant missing behavior that would prevent an agent from invoking the tool correctly.

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

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

The tool has zero parameters, so parameter documentation is not needed. The description adds value by explaining the meaning and structure of the returned domain objects, including examples of time horizons and the field list, which is more context than the empty 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 description opens with a specific verb and resource: 'List all available trading domains on dMoERA.' It explains what domains are and how they relate to strategies, which makes the purpose concrete and distinguishable from the sibling tools, which all deal with funds, bots, strategies, or market data rather than domain listing.

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 contextual guidance: strategies must declare a domain, so the tool is the natural way to discover what domains exist. It does not explicitly state when not to use it or list alternatives, but there are no sibling tools that list domains, so the lack of explicit exclusions is not a meaningful gap.

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 full burden. It states the return type (JSON array) and enumerates the fields, which gives useful behavioral insight. However, it does not disclose side effects (though likely read-only), authentication requirements beyond 'authenticated user', or potential limitations like pagination. This is adequate but not rich.

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

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

The description is two sentences with no redundancy. The purpose is front-loaded in the first sentence, and the return format is summarized in the second. Every word contributes to clarity, making it appropriately concise 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?

For a simple no-parameter list tool, the description is largely complete. It specifies the scope (active + closed) and enumerates the exact fields returned, which is helpful given the output schema is not shown. It does not mention ordering or pagination, but for a basic list operation this is a minor gap. The context is sufficient 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?

The tool has zero parameters, so the description does not need to explain parameter semantics. The input schema is trivially covered (100%), and the description adds no parameter-specific information. Per calibration, a no-parameter tool receives a baseline of 4, which is appropriate 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 clearly states the action (list), the resource (all hedge funds), and the scope (authenticated user, active + closed). It distinguishes from siblings like get_fund (single fund) and get_active_fund (active only) by explicitly saying 'all' and 'active + closed'. The verb-resource pair is 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 implies usage for obtaining the complete list of funds, but does not explicitly mention alternatives or when not to use this tool. Sibling tools such as get_fund and get_active_fund exist, but no exclusions or routing guidance is provided. The context is somewhat self-evident, but it relies on the agent to infer the distinction.

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 discloses the scope (only the caller's own bots), the included bot types (personal, incubating, live), the included data (live engine stats and gamified card ratings), and the return format (JSON array).

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

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

The description is concise and well-structured: a clear one-line purpose, a short contextual caveat, and a focused parameter note. Every sentence earns its place 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 gives enough information to invoke the tool correctly: ownership scope, eligibility categories, returned data, and the optional domain filter. Minor omissions like pagination or default behavior when domain is absent are acceptable given the simple tool shape and output schema.

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

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

Schema description coverage is 0%, but the description adds meaningful guidance for the sole parameter: 'domain: Filter by domain (e.g. "eth_usdc")'. It goes beyond the schema's bare title/default and provides a concrete example.

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: 'List the authenticated user's OWN bots eligible for a personal fund roster.' This clearly distinguishes it from sibling tools like list_bots, get_marketplace_bots, and list_open_source_bots by emphasizing ownership and fund-roster eligibility.

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 explains the personal-fund context and explicitly states that personal funds can never contain another user's bots, implying this is the right tool when the caller needs their own eligible bots. It does not explicitly name alternatives, but the usage context is clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal what the tool returns ('a JSON array of bot entries with gamified card ratings') and describes the data as 'normalized stats and capacity info.' However, it does not explicitly state that this is a read-only/research-only operation or disclose any limitations beyond the personal-funds note.

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-loads the core purpose in the first sentence. The NOTE, args section, and return-type mention all serve useful purposes. Minor redundancy exists between 'Browse open-source bots' and 'This tool is for researching the broader bot ecosystem,' but the overall structure 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?

For a simple tool with one optional parameter and an output schema, the description covers the key facts: what the tool does, how the param works, and what the response looks like. The main gap is the lack of guidance differentiating it from get_marketplace_bots, but the description is otherwise sufficient for an agent 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%, so the description must compensate for the undocumented 'domain' parameter. It does so adequately by explaining 'Filter by domain' and providing a concrete example, 'eth_usdc.' This meaningfully adds value beyond the bare schema, though it does not enumerate possible domain values.

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 and resource: 'Browse open-source bots with normalized stats and capacity info.' It also adds context with 'This tool is for researching the broader bot ecosystem,' which helps define its role. However, it does not explicitly differentiate it from the similarly named sibling get_marketplace_bots, so it stops short of a 5.

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

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

The description gives explicit usage context with the NOTE, explaining that personal funds only contain the authenticated user's own bots and directing agents to list_my_bots for roster-eligible strategies. It also states that this tool is for ecosystem research. It does not mention when to prefer closely related alternatives like get_marketplace_bots, but the guidance provided is clear and specific.

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 disclosure burden. It explicitly says the tool returns a JSON array and lists all returned fields, which tells an agent what to expect. The verb 'List' implies a non-mutating read, though it does not mention authorization, ordering, or edge cases.

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

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

The definition is compact and front-loaded: a one-sentence purpose, an Args line, and a Returns line. The return-field list adds a little redundancy given the output schema exists, but it is still brief and scannable.

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 listing tool, the description covers the action, argument meaning, and return shape. It omits alternative routing and edge-case behavior, but nothing essential is missing for calling 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?

The input schema only provides the property name and type string, so the description is the sole source of meaning. 'user_id: The creator's user ID' fully conveys the parameter's role. It could go further with format guidance, but for a single required parameter this is sufficient.

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, 'List all strategies created by a user,' uses a specific verb and resource and makes the scope (per creator user_id) explicit. This cleanly differentiates it from sibling list tools like list_bots and list_funds.

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 establishes that the tool is appropriate for listing strategies by creator and requires a user_id, which is clear context. However, it does not state when to prefer an alternative such as get_strategy_report, nor does it give exclusions or prerequisites beyond the user_id argument.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the key side effect (wind-down of positions) and states the return shape (success or error), which is meaningful. It does not mention irreversibility, permissions, or ordering constraints, but the main behavioral trait is covered.

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: the action and consequence appear in the first sentence, followed by a compact Args list and a one-line return note. 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 three-parameter mutation with an output schema, the description covers the action, side effect, parameters, and return. It would be more complete with a warning about the wind-down being potentially irreversible and with explicit guidance on when not to use it, but these are gaps rather than fatal omissions.

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 prose must compensate. The Args block explains fund_id as the fund's ID, bot_id as the bot to remove, and reason as optional, adding semantics beyond the bare titles and types. It could specify formats or constraints, but it covers the essentials.

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: 'Remove a bot from a fund's roster,' and adds the important side effect of triggering wind-down of positions. This clearly distinguishes it from add_bot_to_fund and swap_bot_in_fund.

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 about when to use this tool instead of add_bot_to_fund, swap_bot_in_fund, or deactivating a fund. The intended use is implied by the verb, but the description does not provide conditions, prerequisites, 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 burden of behavioral disclosure. It reveals that the tool queries closed positions, combines results into a combined PnL time-series, and is rate limited to 1 request per 30 seconds. 'Simulate' also implies non-destructive, read-only behavior, and the return behavior is 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 description is compact and well organized: a one-sentence summary, a concise methodology/rate-limit note, and clear Args/Returns sections. Every sentence earns its place without padding 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 tool with two parameters and an output schema, the description covers the essential invocation details: parameter structure, default, rate limit, and return summary. It does not explain what 'diagnosis' means or how historical period availability is determined, but those are secondary to calling 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 coverage is 0%, so the description must supply meaning for the parameters. It does so by defining roster as a list of {'bot_id': str, 'weight_pct': float} and initial_capital as starting capital with a default of 10000. It could add constraints about weight ranges or required fields, but it compensates well for the schema's lack of 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 opens with a specific verb and resource: 'Simulate how a roster of bots would have performed historically.' It clearly separates this from siblings like get_fund_performance by emphasizing historical simulation of a custom weighted roster rather than live/current performance. The methodology sentence further pins down what the 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 gives clear context: use this when you want a historical, weighted simulation of multiple bots' closed positions. It does not explicitly name alternatives or provide when-not-to-use guidance, but the use case is unambiguous enough that an agent can infer when to select 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 provided, the description carries the full disclosure burden and does so well. It states the code is run through static checks and a full historical backtest, that nothing is persisted, and that no Strategy or StrategyVersion rows are created. It also describes the JSON return shape including success, metrics, and error details, giving the agent a solid model of 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 key behavioral distinction: sandbox, no persistence, fastest path. The Args and Returns sections are compact and every sentence adds value. There is no filler or repetition 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?

Given the tool's moderate complexity, an output schema exists, and 4 parameters are documented directly in the description, this is complete. The agent knows the required input shape, the strategy contract constraints, the defaults, the lack of side effects, and the return structure. 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 must compensate, and it does thoroughly. Every parameter is explained with types, examples, and constraints: code must define METADATA and extend Strategy with on_bar, domain and symbol get concrete examples, and user_id's purpose is disclosed. It even references CREATOR_API.md for the full contract.

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: 'Run a sandbox backtest of strategy code without persisting anything.' It distinguishes the tool from submit_strategy and similar persistence-heavy siblings by explicitly stating no Strategy or StrategyVersion rows are created. This leaves no ambiguity about what the 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 clearly says this is the fastest way to test a strategy and should be used for rapid iteration. It implies but never explicitly names the alternative for when persistence is desired, such as submit_strategy. The guidance is clear on context but not exhaustive on when-not-to-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 and does so thoroughly. It discloses the complete validation pipeline (including holdout being pass/fail only), the post-condition of status='incubating', and that promotion to live requires a proven track record. It also states the structure of the return JSON, including error 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 organized efficiently: purpose, numbered pipeline, post-conditions, argument list, and return format. Every section adds necessary information and the pipeline breakdown is valuable rather than fluff. It remains readable despite its length.

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 complexity (7-stage pipeline, registration side effects, multiple parameters), the description is complete: it covers the validation process, success/failure outcomes, promotion path, parameter semantics, and return schema. The only mild gap, alternative tool selection, is already covered under usage guidelines. An agent has enough context to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate and largely does. The Args section explains all five parameters with meaningful semantics: 'code' is described as 'Python source code implementing the Strategy contract', 'domain' gets an example, and 'symbol' is tied to historical data. It could go further with constraints or allowed values, but with no enums present it is solid.

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: 'Submit a strategy for full validation and live deployment.' It then enumerates the 7-stage validation pipeline, making it clear what the tool does and how it differs from simpler test or report tools. The mention of live paper trading adds further distinction from 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?

The description implies when to use the tool (submitting a strategy for full validation and live deployment) but does not explicitly contrast with alternatives such as sandbox_backtest, which seems like the main alternative for testing without deployment. There are no exclusion criteria or when-not-to-use guidance, leaving routing decisions partially 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 states the side effects (closes old bot's positions, opens new ones), the associated cost (friction), and the return value (updated roster entry and friction estimate). This is comprehensive and honest about the tool's mutation 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: a clear purpose statement, a sentence on side effects and cost, then a list of parameters. The parameter documentation is justified given the 0% schema coverage, and every sentence adds value without verbosity. It is front-loaded with the most critical information.

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

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

Given the tool's complexity (6 parameters, no annotations, 0% schema coverage) and the presence of an output schema (not shown but flagged as true), the description covers all necessary ground: it explains the prerequisite, the behavioral effect, the parameters, and the return type. An agent would have everything needed 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 compensate. It does so with a dedicated 'Args' section that explains each parameter's role, including defaults (weight defaults to old bot's weight) and optionality (reason). This adds meaningful meaning beyond the bare type declarations 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 opens with a precise verb-object phrase, 'Swap one bot for another in a fund's roster,' and immediately explains the operational effect (closes old positions, opens new ones). This clearly distinguishes it from sibling tools like add_bot_to_fund or remove_bot_from_fund, leaving no ambiguity about what the 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 gives an explicit prerequisite: 'use estimate_swap_cost first.' This is actionable guidance that tells the agent when to call a different tool before this one. It does not explicitly list alternatives or when-not-to-use conditions, but the strong contextual clue is sufficient for an agent to route correctly.

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 behavioral context. It reveals that the tool returns a set of named badges for the authenticated user, implying authentication is required. However, it does not disclose behavior such as error conditions, empty results, or any side effects. The listing of badges adds some transparency but leaves gaps like rate limits or authorization 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 two sentences, front-loading the purpose and then providing a helpful list of badge names. There is no redundant information; every word contributes to understanding the tool's output. This is an efficient and well-structured description.

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 tool with an output schema, the description is nearly complete. It clearly states the operation and lists expected badge values. It does not mention authentication prerequisites or behavior for users without badges, but these are minor given the tool's simplicity and the presence of an output schema.

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

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

The tool has zero parameters, and the schema is empty with 100% coverage implied. According to the baseline for 0-parameter tools, a score of 4 is appropriate. The description adds value by enumerating the specific badges returned, which is more informative than the empty schema, though it does not address parameters since none exist.

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' and identifies a specific resource: the authenticated user's Tag Team badges. It lists the exact badge names, distinguishing it from sibling tools like tag_team_leaderboard or tag_team_history. 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?

The description states the tool's purpose but does not explicitly specify when to use it versus alternatives like tag_team_info or tag_team_leaderboard. Usage is implied by the tool's name and content, but there is no explicit guidance on when not to use it or which sibling to prefer for other badge-related 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 present, so the description carries the transparency burden. 'Get' and 'authenticated user's past' indicate a read-only, self-scoped operation and imply authentication. However, it does not disclose pagination, ordering, or empty-result behavior, though the output schema covers return structure.

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 verb and resource and contains no filler. Every word adds meaning and it is appropriately sized for a zero-parameter read 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 zero-parameter tool with an output schema, the description is nearly complete: it states the resource, scope, and returned content. It could be slightly more complete by explicitly routing the agent away from similar tag_team_* sibling tools, but that gap is small.

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

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

The input schema has zero properties, so there are no parameters to document or clarify. The no-parameter baseline of 4 applies because there is no possible ambiguity in 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 uses a specific verb ('Get') and a concrete resource ('the authenticated user's past Tag Team sessions with scores'). It clearly differentiates this tool from sibling tag_team_* tools such as leaderboard, templates, weekly, and badges, even without naming them 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?

No guidance is given about when to use this tool versus its tag_team_* siblings, nor any exclusions such as current/upcoming sessions. The description only states what the tool does, leaving the selection 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, the description carries the behavioral disclosure burden. It frames the operation as read-only through 'Get' and 'Returns', and notes it targets the authenticated user's session. However, it does not mention auth/permission requirements, data freshness, rate limits, or explicitly confirm no side effects, 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 purpose is front-loaded in the first line, followed by a compact Tag Team explainer and a one-line return summary. The explainer is slightly longer than strictly necessary for a zero-param read tool, but it makes the returned fields meaningful for an agent unfamiliar with the domain.

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

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

For a zero-parameter read tool with an output schema, the description covers the essential context: what Tag Team is, whose session is returned, and what categories of data are included. It could add sibling routing information, but that gap is already reflected in usage_guidelines; overall this is complete enough for 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 tool has zero parameters, so the baseline of 4 applies. There are no parameter semantics to clarify, and the description appropriately focuses on what the call returns rather than inventing parameter details.

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

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

The first sentence names a specific verb and resource: 'Get the authenticated user's Tag Team session info.' The final sentence enumerates the returned data (session state, open positions, bot status, rank), which clearly distinguishes it from sibling tools like tag_team_history, tag_team_leaderboard, and tag_team_tier.

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 call this tool versus alternatives such as tag_team_history or get_tournament_status. The Tag Team product explanation provides useful context, but it does not give selection criteria, exclusions, or when-not-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?

No annotations are provided, so the description carries the transparency burden. It usefully discloses qualification rules and the exact score formula, which are not inferable from the schema. It does not explicitly state read-only behavior, but the tool name and 'Get' verb strongly imply it.

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-line purpose, a clearly labeled argument block, and the scoring rule. Every sentence adds necessary information 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?

This is a low-complexity read tool with one optional parameter and an existing output schema, so return values do not need extra explanation. The description covers purpose, parameter behavior, and scoring qualification, which is sufficient 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?

Input schema coverage is 0%, but the description thoroughly documents the single date parameter: the YYYY-MM-DD format and the default behavior of 'today'. This is exactly the semantic information an agent needs beyond the bare schema.

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

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

The description opens with a specific verb and resource: 'Get the daily Tag Team leaderboard.' The 'daily' qualifier distinguishes it from sibling tag_team_weekly, and the rest of the description focuses on leaderboard mechanics. An agent can immediately tell 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 makes the daily nature explicit and documents date filtering, which implies when this tool is appropriate versus weekly leaderboard siblings. It does not explicitly name alternatives or state when not to use it, so it falls just short of full usage 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 provided, so the description carries that burden. It goes beyond a simple 'list' by disclosing that template parameter ranges are tunable and trained settings persist between days, which is meaningful behavioral context and helps an agent reason about state.

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

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

Three sentences with no filler: the first states the action, and the next two add useful detail about what templates define and how parameters persist. Every sentence earns its place and the key purpose 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 zero-parameter listing tool with an output schema, the description covers the important conceptual ground: what a template is, what it controls, and that training carries over. It doesn't describe return content, but the output schema covers that, and no critical invocation detail 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 input schema has zero parameters, so there is nothing to document; the baseline of 4 applies. The description's mention of template semantics adds value without needing to explain any arguments.

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: 'List all available Co-Pilot templates,' then gives concrete examples like momentum and scalper. This makes the tool's purpose unmistakable and distinguishes it from sibling bots/funds/strategies listing 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 communicates the domain context: templates define signal logic and parameter ranges, and bot params persist across days. However, it never explicitly tells an agent when to choose this tool over sibling alternatives like list_bots or get_marketplace_bots, nor does it state any 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 behavioral burden. It adds useful context by explaining that tiers are based on total trades across all sessions and persist across days, which is meaningful beyond the tool name. It does not explicitly state side effects, but 'Get' strongly implies a read-only operation.

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

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

The description is appropriately sized and front-loaded with the core purpose. The tier list is concise and directly relevant to interpreting the result, and every sentence adds value.

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

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

For a zero-parameter read tool with an output schema available, the description provides sufficient context: what the tool returns, the meaning of the tier values, and the persistence behavior. Nothing essential 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 is not required to explain parameter behavior. The schema already covers the empty parameter set completely, and the description adds no conflicting or confusing parameter information.

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 specific resource: the authenticated user's Tag Team tier and stats. It does not explicitly contrast with sibling tools like tag_team_info, but the resource is distinct enough that an agent can identify the tool's 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 implies the tool should be used when the authenticated user's tier or trade-based stats are needed, which provides some context. However, it gives no explicit guidance on when not to use it or how it differs from closely related Tag Team sibling tools such as tag_team_info or tag_team_badges.

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

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

The description adds a nontrivial behavioral detail: standings are based on the best 5 daily scores per user. With no annotations, it does not disclose other behavioral aspects such as read-only semantics or period handling, though 'Get' and the presence of an output schema cover some of this.

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; the parenthetical adds the only non-obvious detail. It is concise, scannable, and every word earns its place.

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

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

For a zero-parameter query tool with an output schema present, the description is largely sufficient: an agent can invoke it without arguments and knows the result is weekly standings. It lacks explicit placement among the tag_team siblings, but that gap is more about usage guidance than invocation completeness.

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 an empty schema, so there are no parameter semantics to document. The description correctly indicates the data scope, which is the only relevant semantic content.

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 ('weekly championship standings') and clarifies the scoring rule ('best 5 daily scores per user'), making the tool's purpose clear. It does not explicitly contrast with siblings like tag_team_leaderboard or tag_team_history, 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?

No when-to-use or alternative guidance is provided; the description only states what the tool does. With several tag_team_* siblings present, the agent receives no help deciding between weekly standings and the leaderboard/history 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 behavioral burden. It usefully discloses that 'Only provided fields are updated; others remain unchanged' and that it returns success or error Face, but it does not mention validation rules, permission requirements, or side effects beyond the described update.

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, an Args list covering all parameters, a key behavioral note, and a return statement. No filler 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 four-parameter update tool with no annotations, this description covers purpose, argument semantics, partial-update behavior, and return value. It could be more complete with explicit mention of alternatives or edge cases, but nothing critical to invoking it correctly is missing.

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

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

The input schema provides only field names and types with 0% schema description coverageskin. The description fully compensates by explaining each parameter, including units for percentages ('40.0 = 40%') and the meaning of regime_veto_enabled. This is exactly the kind of semantic context an agent needs.

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

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

The description states a specific action and resource: 'Update a fund's risk caps and settings.' It is clear and distinct from nearby tools like update_fund_weights, though it does not explicitly differentiate itself from that sibling.

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 the name and the verb 'Update a fund's risk caps and settings.' There is no explicit guidance about when to prefer this tool over update_fund_weights or other fund-updating siblings, nor any exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Returns success or error,' without revealing whether the update overwrites all weights or merges with existing ones, whether weights must sum to 100, or how invalid bot_ids are handled. As a mutation tool, these are material 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 compact, front-loads the one-sentence purpose, and uses a clear Args block. No filler or redundant restatement of the schema is present.

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

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

For a two-parameter fund update tool, the description supplies enough to construct an initial call, and there is an output schema despite its absence here. However, missing behavioral details such as whether weights are a full replacement or a partial update, and whether a specific total is required, keep it from being 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's Args section is essential and does add real meaning: it labels fund_id as the fund's ID and explains that weights is a dict mapping bot_id to a weight percentage, with a concrete example. While it stops short of documenting constraints such as valid ranges or required sum, both parameters are clearly explained for a basic call.

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

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

The description opens with a specific verb and resource: 'Update allocation weights for bots in a fund's roster.' This clearly identifies the tool's unique role among siblings, especially distinguishing it from update_fund_caps and other fund-management 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 the tool is for rebalancing bot weights in a fund, but it does not explicitly state when to choose this over update_fund_caps, add_bot_to_fund, or other alternatives. There are no usage exclusions or prerequisites, so the agent must infer the context from the tool name and resource.

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