dMoERA Creator

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

With no annotations at all, the description carries the full burden and does real work: it discloses that capital gets deployed per roster weights and risk caps, that the main platform router is paused while active, and that the rationale is published publicly on the manager's log. Missing are permissions/prerequisites (fund must exist and be inactive) and reversibility, which is why it stops short of 5.

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

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

Front-loaded with the action, then the behavioral consequence, then a compact Args block. Every sentence earns its place; only the trailing 'Returns success or error' is low-value 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?

An output schema exists, so return values needn't be spelled out, and both parameters plus the key side effects are covered. The remaining gap is preconditions — that the fund must exist and currently be inactive, and what happens if activation fails.

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: fund_id is identified as the fund's ID and rationale is marked REQUIRED with the consequential detail that it is published on the fund's public manager's log — information found nowhere in the schema. It leaves the integer/identifier format to the schema, which is acceptable.

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

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

States a specific verb and resource (activate Manager Mode for a fund) and immediately explains the mechanism: it starts the personal router and deploys capital across the fund's roster bots. That distinguishes it in practice from deactivate_fund and run_ai_manager, though no sibling is named explicitly.

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

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

The 'going live' framing and the note that the main platform router is paused imply when to use it, but there is no explicit when-to-use/when-not guidance and no named alternative (deactivate_fund, run_ai_manager) for the agent to route against.

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

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

With no annotations, the description carries the full burden and does well: it discloses the ownership eligibility rule, that the rationale text is published publicly in the manager log (a real, non-obvious side effect), and that the call returns the updated roster entry. It omits duplicate-handling, roster size limits, and manager-permission requirements.

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

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

Front-loaded statement of effect, then the eligibility constraint, then parameters. The Args block is justified because the schema has zero descriptions, though the docstring formatting is slightly verbose for a five-field 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?

An output schema exists, so return values need only light treatment and the description handles it in one line. For a mutation with no annotations, the key risks — eligibility, public log exposure, initial weight semantics — are all covered; failure modes and permission requirements are the missing pieces.

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

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

Schema coverage is 0%, so the description must compensate and does: all five parameters are explained with units (weight in percent, default 20.0), concrete examples ("momentum_eth_v3", "eth_usdc"), and a purpose for rationale. An agent can populate every field without opening the schema.

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

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

States a specific verb and resource: "Add a bot to a fund's roster." This clearly separates it from remove_bot_from_fund and swap_bot_in_fund by semantics, and the personal-fund eligibility line narrows scope further. It stops short of naming the sibling it should be preferred over, so not 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?

"Use list_my_bots to see eligible strategies" gives an explicit prerequisite step, and the personal-funds restriction tells the agent when this call is even valid. No guidance on add vs. swap_bot_in_fund or set_fund_lineup for replacing a bot, which is the remaining 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses the core effect ('resizes mirrored positions') and allocation range, but does not state permissions, reversibility, what happens to existing positions during resizing, or whether the change is immediate.

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 and concise: a single purpose sentence followed by two short argument descriptions. No sentence is wasteful.

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

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

An output schema exists, so return values need not be explained. However, for a mutation tool with no annotations, the description is only partially complete: it covers parameters and the resizing effect but omits permissions, state safety, and explicit usage boundaries.

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: fund_id is explained as 'The fund you're copying' and allocation_pct as the new percentage of the paper portfolio with a 1-100 range. It covers both parameters meaningfully, though fund_id format remains implied by the schema type.

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

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

The description states a specific verb and resource ('Change the slider on an active copy') and adds a concrete effect ('resizes mirrored positions'), which distinguishes it from start/stop copy tools. It does not explicitly name a sibling alternative, but the purpose is clear.

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

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

'on an active copy' implies the copy must already exist and is not being started or stopped, giving some usage context. However, there is no explicit guidance on when to use this versus start_fund_copy, stop_fund_copy, or get_fund_copy_state.

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

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

With no annotations, the description carries the full burden and does so well: it discloses irreversibility, the capital-return side effect, that the performance record survives for reporting/copy-trader settlement, and that the rationale is published publicly. That last point is a non-obvious, decision-relevant disclosure an agent would otherwise miss.

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

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

Front-loaded with the action, then the irreversibility warning, then per-argument notes — every sentence earns its place except 'Returns success or error', which is filler given an output schema exists.

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?

Covers destruction, side effects, and post-close data retention, which is enough for correct invocation; the output schema means returns needn't be explained. The remaining gap is not routing the agent to deactivate_fund as the reversible alternative.

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

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

Schema coverage is 0%, so the description must compensate. It adds real meaning for 'rationale' (publicly published) but 'fund_id: The fund's ID' is tautological, leaving the identifier's expected format/source unexplained.

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

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

States a specific verb and resource ('Permanently close a hedge fund') plus the key outcome ('returns all capital to the wallet'). It doesn't name deactivate_fund, the obvious sibling alternative, so the contrast is only implied by 'permanently'.

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?

'Permanently' and 'irreversible' effectively signal when this applies versus a reversible pause like deactivate_fund, giving clear context. There is no explicit when-not clause or named alternative, which keeps it short of a 5.

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

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

With no annotations, the description carries the full burden and does add real substance: weights summing under 100 leave the remainder in cash, an empty roster means all cash, weights may not exceed 100, leverage applies to new positions, and router sizing skips bots without history. It does not state permissions, whether the formation becomes active, cost, or behavior on name collision. It also labels rationale as REQUIRED even though the schema marks only fund_id required, an inconsistency an agent could trip on.

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

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

Front-loaded with the action, then a compact Args block where nearly every line carries a non-obvious constraint. The docstring formatting is slightly verbose but no sentence is filler; the "rationale: REQUIRED" capitalization is the only place it wastes emphasis on something the schema contradicts.

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

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

For a 10-parameter mutation tool with no annotations, the description covers creation semantics, mode selection, and roster constraints, and an output schema exists so return values need not be explained. Remaining gaps are lifecycle (does the formation go live?) and failure conditions, which matter for a write tool.

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

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

Schema description coverage is 0% across 10 parameters, so the description must compensate fully and does: every parameter is explained with format or range, including the roster object shape with an inline example, the leverage 1-20x bound, and the two accepted sizing values ("weights" default, "router" Kelly sizing). This is more information than the schema provides by a wide margin.

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?

"Save a formation on the fund's bench" gives a specific verb and resource, and "bench" implies a saved-but-not-live configuration, which distinguishes it from switch_formation. It never explicitly contrasts itself with update_formation or create_fund, so the sibling differentiation is implied rather than stated.

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 parameter notes double as mode selection guidance: use template_key to start from a template (pointing to list_formation_templates) or from_current to snapshot the live roster. It lacks an explicit statement of when to call this versus update_formation or switch_formation, but the routing cues are clear enough to act on.

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

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

With no annotations, the description carries the full burden and does disclose key behavior: the created entity starts inactive, initial capital is debited from the user's wallet_cash at creation time (a real financial side effect), and it returns the created fund object. It does not mention permission requirements, failure modes (insufficient wallet_cash), or reversibility, which keeps it short of a 5.

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

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

Front-loaded with the core action and the activate_fund follow-up before the Args block, which is justified given the zero schema coverage. A few lines are near-redundant ("Display name for the fund"), but overall it is tight for a five-parameter creation 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?

An output schema exists, so "Returns the created fund object" suffices for return values, and the lifecycle plus funding behavior are covered. The only real gap is what to do when wallet_cash is insufficient or when the user already has a fund, which an agent would have to discover by trial.

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: all five parameters are explained with defaults and enumerated values (router_preset's four risk profiles, aggression_mode's weights vs. router with the Kelly-sizing precondition, fund_type's three variants and their bot composition). This adds meaning well beyond the bare schema titles.

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

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

Opens with a specific verb and resource ("Create a new hedge fund") plus the scope ("for the authenticated user"), which separates it cleanly from activate_fund, get_fund, list_funds and the other fund siblings. An agent can identify the operation without opening the schema.

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

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

Explicitly states the post-creation lifecycle step ("fund starts inactive — call activate_fund to start Manager Mode") and points at list_marketplace_bots for the fieldable_in check when picking open-source bots. It lacks any when-not-to-use condition (e.g. one fund per user, or existing funds), but the surrounding 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?

No annotations, so the description carries the full behavioral burden. It does disclose the destructive effect (all positions closed, capital returned) and the success/error return, which is genuinely useful, but it says nothing about authorization requirements, reversibility, or what happens to active copies/followers of the fund during deactivation.

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

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

Front-loaded with the primary action and its consequence, then a compact Args block. The 'returns to the main platform router' clause is somewhat opaque jargon but costs only one clause.

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

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

Output schema exists, so the brief 'Returns success or error' is sufficient. Still, for a destructive lifecycle tool in a cluster of activate/close/deactivate siblings, the missing differentiation from close_fund and the absent reversibility note leave real gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It does well for rationale — marking it REQUIRED and warning that it is published publicly on the manager's log, which shapes wording choices — but fund_id is only restated tautologically as 'The fund's ID' with no format or sourcing hint.

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

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

States a specific verb and resource ('Deactivate Manager Mode') and adds concrete consequences: closes all roster bot positions and returns capital to the wallet. However, it never distinguishes itself from the sibling close_fund, which sounds like it could do the same or more.

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 on when to choose this over close_fund, nor any statement that activate_fund is the inverse for reactivating. The reader must infer the relationship from sibling names alone, and the fund_id line offers no scenario 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 does real work: it discloses that rationale is mandatory and that it is published on the manager's log, an externally visible side effect an agent wouldn't otherwise know. It omits whether deletion is reversible, what happens to bots assigned to that formation, and any permission requirements.

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

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

Two short sentences, no waste, with the scoping constraint front-loaded and the critical REQUIRED constraint on rationale given next. Every clause 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?

Output schema exists, so return values needn't be described. But for a destructive tool with zero annotations, the description should state reversibility and side effects on dependent entities; it covers only the rationale requirement and the log publication.

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% — fund_id and formation_id carry only titles in the schema, and the description adds nothing about them. It does fully explain the rationale parameter (required, its purpose, and its published destination), which partially compensates but leaves two identifiers undocumented.

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 (delete) and resource (formation) plus a scoping qualifier, 'from the bench (not the one on the field)', which separates it from switch_formation and update_formation without naming them. An agent can identify the operation, though the sibling names themselves aren't cited.

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 parenthetical 'not the one on the field' implies a when-not condition (don't delete the active formation), but it stops short of naming the alternative action (switch_formation first, then delete) or stating 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the authorization scope (own replies or manager moderation under your fund's posts), but does not mention irreversibility, confirmation requirements, or what happens to associated data after deletion.

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

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

The description is short, front-loaded with the core action and scope, and the Args block is minimal but sufficient. 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?

The tool is a destructive mutation with no annotations. The description covers ownership and moderation scope and names the ID source, but does not warn about irreversibility or confirm the effect of deletion. An output schema exists, so return values need not be explained.

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 for the single parameter. It adds valuable provenance by saying the reply_id comes from get_replies, but does not describe expected format, type, or validation beyond that.

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

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

States a specific verb and resource ('Delete a reply') and immediately distinguishes the permission scope: your own reply or any reply under your fund's posts. This is clear enough to distinguish it from siblings like get_replies and reply_to_post.

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?

Explains the ownership/moderation condition for when deletion is allowed and points to get_replies as the source of reply_id. It does not name explicit alternatives or when-not-to-use cases, 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 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, the description carries the full burden and does disclose the key traits: the user-visible effect on the following feed, a hard restriction (cannot follow own fund), and that omitting follow toggles existing state. It does not cover error behavior when the constraint is violated or idempotency, keeping it below 5.

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

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

Purpose and restriction are front-loaded in two short sentences, then parameters in a compact Args block. Every line conveys information an agent needs; nothing is padded.

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

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

An output schema exists so return values needn't be explained, and both parameters plus the self-follow restriction are covered. It is slightly incomplete on what happens on a rejected self-follow or whether unfollowing removes past feed items, but nothing essential 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?

Schema coverage is 0% and the schema only shows follow as a nullable boolean with default null, so the description supplies crucial meaning: true=follow, false=unfollow, omit=toggle. That non-obvious tri-state behavior is not inferable from the schema and materially changes how an agent calls the tool.

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

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

States a specific verb and resource ('Follow a fund') plus the observable effect ('its posts surface in your following feed tab'), which is more than the bare name. It does not name a sibling (e.g. get_follow_state) to disambiguate against, 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?

It gives a real usage constraint ('You can't follow your own fund') and explains the follow flag's toggle behavior, which is genuinely helpful context. However, there is no explicit guidance on when to call this versus get_follow_state or read_feed, so routing is implied rather than stated.

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

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

With no annotations 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose the identity-resolution fallback logic, which is real behavioral context, but it says nothing about read-only safety, whether the call can fail when no identity exists, or what the returned persona depends on.

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

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

A single sentence with the resource front-loaded and the resolution rule appended after a dash. Every clause carries information, and nothing is repeated.

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 getter with an output schema, the description covers what the tool returns and the fallback rule that determines it. It is close to complete, but leaves open whether the call errors or returns an empty value when no identity exists.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. Schema coverage is 100% and an output schema exists, so the description does not need to compensate further.

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 resource — the identity used for posting and replying on the feed — and explains its resolution rule (fund persona if the user runs a fund, otherwise username). That distinguishes it meaningfully from generic profile tools like get_manager_profile or get_bot_profile, though it never names those siblings explicitly.

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

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

The phrase 'who you post/reply as' implies the tool is relevant before posting or replying, but it never says when to call it versus get_manager_profile, get_bot_profile, or get_active_fund. Usage is inferable rather than stated, with no exclusions or alternatives.

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

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

With no annotations, the description carries the full burden. It discloses the two returned values and implies a read operation tied to 'YOU', but says nothing about authentication requirements, side effects, or rate limits.

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

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

The main purpose is front-loaded in one short sentence, and the only extra content is a boilerplate Args block. It is appropriately sized for a simple one-parameter getter.

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

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

The output schema covers return values and the tool is simple, but the description omits authentication context and does not relate this to the follow/unfollow siblings. It is minimally sufficient but has clear gaps for a personal-state endpoint.

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

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

Schema description coverage is 0%, so the description must compensate, but 'fund_id: The fund's ID' only restates the parameter name without explaining format, valid source, or lookup context.

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 retrieval: follower count plus whether the current user follows the given fund. It is clear enough to distinguish from mutation siblings like follow_fund, though it never names an alternative 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?

There is no guidance on when to use this tool versus follow_fund or get_fund. The only hint is the implied read-only 'get' usage, with no exclusions or context about when the result is useful.

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 must carry behavioral disclosure. It usefully clarifies that the result includes public aggregate copy stats and conditionally the caller's own copy, but it does not mention read-only safety, auth requirements, error behavior, or rate limits—gaps partially mitigated by the get_ prefix and the output schema.

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

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

The definition is two short sentences plus an args line, with the core purpose front-loaded. The args line is mildly redundant but not verbose, and every sentence serves the small scope of the tool.

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

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

Given one parameter and an existing output schema, the description adequately summarizes what data is returned, including the public/personal split. However, it omits permissions, null/omitted behavior when the caller has no copy, and error cases, leaving meaningful context gaps.

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

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

Schema description coverage is 0% for the single fund_id integer, and the description merely restates 'The fund's ID' without adding format, source, or validation details. It provides essentially no meaning beyond the schema's own 'Fund Id' title.

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

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

States a specific verb-resource pair (get_fund_copy_state) and a clear scope: public copy stats (active/all-time copiers) plus the caller's own copy if present. It distinguishes public versus personal data, but does not name or contrast siblings such as get_follow_state or list_my_copies, keeping it below 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?

No explicit when-to-use, when-not-to-use, or alternatives are provided. The conditional 'if you have one' hints at personal context but leaves the agent to infer when this tool should be chosen over list_my_copies, get_follow_state, or get_fund_analytics.

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, the description carries the full behavioral burden. It does disclose the log content, which helps, but it does not mention read-only safety, permission requirements, ordering, pagination behavior, or whether the log is complete history; the 'get' in the name implies read-only but this is not 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 a single front-loaded sentence with no wasted words. It states the resource and the content of the log efficiently, which is appropriate for a simple retrieval 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 two-parameter read tool with an output schema, the description is adequate about what the log contains, but it leaves gaps around parameter usage and pagination behavior. With no annotations, it should do more to explain how limit affects results and what the agent should expect from the log.

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 should compensate for the two undocumented parameters. It gives no explanation of fund_id or limit; the fund scoping is only indirectly implied by 'The fund's manager's log', and the limit parameter and its default of 30 are not addressed at all.

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 identifies the resource clearly as the fund's manager log and lists the kinds of entries it contains: switches, roster changes, and notes with rationale. It is more specific than a tautology, though it does not explicitly state the retrieval verb or differentiate itself from nearby siblings such as get_fund_trades or get_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 implies that the tool is used to inspect a fund's manager activity log, but gives no explicit guidance on when to use it instead of get_fund, get_fund_trades, get_fund_report_card, or other fund-history tools. There are no exclusions, prerequisites, or alternatives named.

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?

No annotations are provided, so the description carries the full burden. It implies a read operation through the verb 'Get' and lists the exact fields returned, but never states read-only/side-effect-free status, auth requirements, or what happens with an invalid fund_id.

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

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

One sentence, front-loaded with the verb and resource, followed by the field list. Efficient, though the heavy enumeration partly duplicates what the output schema already encodes.

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

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

An output schema exists, so the return-field list is somewhat redundant, and the tool is a simple one-parameter read. What is missing is the fund_id contract — the one thing an agent could actually get wrong when calling it.

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

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

Schema description coverage is 0% for the single required parameter, and the description says nothing about fund_id — no format, no source, no behavior for missing or unknown funds. With one parameter the compensation burden is small, but nothing is added.

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

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

The description names a specific verb and resource ('Get a fund's manager persona') and enumerates the payload contents (name, avatar, tagline, manager_kind, AI prompt/schedule, socials, leverage, formation). This distinguishes it well from get_fund and get_bot_profile, though it never names a sibling 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?

Usage is only implied by the content list — an agent can infer this is the read counterpart to set_manager_profile. There is no explicit when-to-use, when-not, or alternative 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 does disclose the access scope (any public fund, not just your own), which is genuinely useful authorization context. It says nothing about behavior for private/nonexistent fund_ids, error cases, or whether it is strictly read-only beyond what 'get' implies.

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

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

Two short sentences, front-loaded with the aggregate payload and followed by the scoping caveat. The content list is dense but readable; nothing is padded or repeated.

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

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

An output schema exists, so return values needn't be spelled out, and for a single mandatory parameter the surface is small. Still missing are how to source fund_id and what happens if the fund is private or invalid, which an agent would need before calling reliably.

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 single fund_id parameter is documented nowhere — not its meaning, its format, nor where to obtain a valid id (e.g. list_funds). The description only implies it by referring to 'a fund's public page', which does not compensate for the coverage gap.

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

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

Specific verb (get) plus a clearly scoped resource (a fund's public page), with an explicit enumeration of the sections returned: persona, philosophy, prompt, formations, roster, positions, track record, log. It implicitly separates itself from get_fund via 'works for any public fund, not just yours', though it never names that sibling directly.

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

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

The phrase 'works for any public fund, not just yours' hints that this is the cross-fund variant versus get_fund/get_active_fund, but the alternative is never named and no explicit when-to-use rule is given. An agent has to infer the routing from the word 'public'.

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. 'List' reasonably implies a read-only, non-mutating call and the field preview hints at shape, but there is no mention of ordering, pagination, volume limits, or empty-result 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?

Two short lines, purpose first, then the single argument's provenance. Nothing redundant and nothing padded.

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?

A trivial single-parameter read tool with an output schema present, so return values needn't be spelled out. The only shortfall is absent guidance on result volume or paging, which matters mildly for a list endpoint.

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

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

Schema coverage is 0% and the lone parameter is a bare integer named action_id, so the description is doing real work by clarifying it is the post's id sourced from read_feed rather than a reply id. With only one parameter fully accounted for, that is close to adequate.

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

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

States a specific verb and resource (list replies under a feed post) and even previews the returned fields (authors, text, timestamps). It is easily separable from reply_to_post, delete_reply, and read_feed by name alone, though it never explicitly names those 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 note that action_id is 'The post's id from read_feed' implies the prerequisite flow (read_feed first, then get_replies), which is useful. However, there is no explicit when-to-use/when-not, and no mention of alternatives such as read_wire or reply_to_post for posting a reply.

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, the description carries the full burden, and it does disclose the critical non-idempotent-seeming toggle behavior that an agent would otherwise get wrong. It says nothing about permissions, failure modes (nonexistent post, already-liked edge cases), or side effects on counters, leaving real gaps for a mutation 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?

Two tight sentences with the toggle semantics front-loaded before the parameter note. Nothing is padded, and the docstring-style Args block is minimal.

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

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

Output schema exists, so return values need no explanation, and the single parameter's source is covered. However, for an unannotated mutation tool the description omits auth requirements and error behavior, leaving an agent to discover edge cases at call time.

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

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

Schema coverage is 0%, so the description must compensate; it partially does by giving provenance ('The post's id from read_feed'), which tells the agent where to obtain the value. It adds no format, type, or validation detail beyond that, so it falls short of full compensation for an undocumented parameter.

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

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

States a specific verb and resource ('Like (or unlike) a feed post') and immediately clarifies the toggling semantics, which is the non-obvious part. It does not explicitly distinguish itself from siblings like reply_to_post or read_feed, but the toggle behavior makes its identity 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?

'Call again to unlike' gives a concrete usage rule for re-invocation, and 'id from read_feed' implies the prerequisite workflow. There is no explicit statement of when to prefer this over related tools or what happens if the post is already in the target state.

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?

No annotations are present, so the description carries the burden. It discloses useful traits — 'Pure exposure, no edge' and 'Allowed in personal and standard funds' — but these describe the bots rather than the tool's behavior (e.g., no pagination, no filtering, no result-size note). For a zero-parameter list tool with an output schema, 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?

Front-loaded with the resource definition, then the use case and constraints. Dense but every clause (what it is, how to use it, where it's allowed) earns its place; only the trailing constraint sentence is arguably secondary.

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

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

For a simple zero-arg list tool with an output schema, the description supplies the category definition, a motivating use case, and eligibility constraints. It stops short of stating how results relate to broader bot listings, but that is a minor gap given the output schema and simplicity.

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

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

The schema defines zero parameters, which is the baseline-4 case. No parameter semantics are needed, and the description does not waste words on nonexistent inputs.

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 identifies the resource as a specific category: 'Directional building-block bots: always long / always short BTC, ETH, SOL.' This distinguishes it from generic siblings like list_bots, though it never explicitly uses a listing verb (implied by the name) and doesn't state whether this is a subset filter of all bots.

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 a usage context ('use them to express a market view in a formation') with a concrete example, which implies when to reach for it. However, it does not compare against alternatives like list_bots, list_my_bots, or get_marketplace_bots, so the agent must infer that this is the directional subset.

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?

No annotations are provided, so the description must carry the behavioral burden. It does disclose the payload shape (roster, weights, settings, is_active) and implicitly that this is a read-only enumeration, but says nothing about permissions, pagination, or whether inactive formations 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?

A single compact sentence that front-loads the resource and lists contents efficiently. The 'bench' framing costs a few words but reinforces the mental model 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?

With an output schema present, return values needn't be explained, and the description covers them at a high level. However, for a tool with zero annotation coverage and an undocumented required parameter, it leaves gaps around access requirements and result scoping.

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 single required parameter fund_id is never mentioned by name. The phrase 'The fund's bench' implies the results are scoped to a fund, but an agent gets no explicit confirmation that fund_id is the scoping key.

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 resource (every saved formation) and enumerates what each entry contains: roster, weights, settings, and is_active. The verb is implied by 'every saved formation' rather than explicit, and the 'bench' metaphor adds flavor without distinguishing it from siblings like list_formation_templates or get_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?

Usage is only implied: an agent can infer this lists formations belonging to a fund. There is no explicit when-to-use versus list_formation_templates, switch_formation, or get_fund, and no stated prerequisites beyond the fund scoping in the label.

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 supplied, so the description must carry the behavioral burden, and it does signal that this is a passive catalog lookup with no side effects by naming only static themes. However, it says nothing about auth requirements, whether templates are global or user-scoped, or any caveats on stale templates.

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

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

Two short sentences with zero filler: the resource description first, the action hook second. Every sentence earns its place for a trivial lookup 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?

With an output schema present and no parameters, the description covers the core need: what the templates are and how to use one. Only minor context is missing, such as whether the template list varies by user or environment.

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

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

The tool takes zero parameters and the schema is empty at 100% coverage, so the description cannot and need not elaborate on parameters. It correctly mentions the template_key argument belongs to create_formation, not to this tool.

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?

Names the resource concretely as "ready-made theme formations" and enumerates the actual templates (BTC Bull, Alt Season, Bear Raid, etc.), so an agent knows exactly what comes back. It stops short of explicitly contrasting with the sibling list_formations, which an agent might confuse it with.

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

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

Gives a clear next step: "Add one with create_formation(template_key=...)", which frames the intended workflow of browsing then instantiating. It doesn't state when this should be preferred over list_formations or switch_formation, so the guidance is context rather than explicit routing.

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

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

With no annotations, the description 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?

No annotations are provided, so the description carries full burden. It does not state that this is a read-only listing, mention pagination behaviour tied to the limit parameter, or clarify any access/permission implications. The phrase 'what's on the field' is vague and adds little behavioural clarity.

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

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

The description is a single front-loaded sentence with no wasted words. However, 'what's on the field' is vague and could be replaced with more specific 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?

While an output schema exists to describe return values, the description omits the limit/pagination behaviour and does not guide usage or differentiation. For a list tool with one undocumented parameter, this is insufficient.

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 single parameter 'limit' has 0% schema description coverage. The description does not mention it at all, so the agent must infer its meaning and effect (e.g., pagination) entirely from the parameter 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?

Names the resource clearly (public fund managers, both human and AI) and hints at content (returns, what's on the field). It does not explicitly differentiate from sibling tools like get_manager_profile or list_bots, but the resource is identifiable.

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

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

There is no guidance on when to use this tool versus alternatives such as get_manager_profile or list_bots. Usage is only implied by the resource name.

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 load, and it does disclose a non-obvious behavioral trait: every bot carries a "fieldable_in" list and mismatched bots are rejected downstream by add_bot_to_fund. It also hints at payload content (stats, capacity, crowd signals). It does not mention read-only semantics, pagination, or result-set size limits, which matters for a browse-all 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?

Front-loaded with purpose and scope, then the fund-type gating rule, then a compact Args block. Every sentence carries information; the parenthetical examples add precision rather than padding. The line breaks are cosmetic and do not hurt scanability.

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?

Two optional params, both explained, and an output schema exists so return values need not be spelled out. The fund-type gating behavior — the one thing that could cause a downstream failure — is covered. Missing only the fund_type default and any notion of result volume for an "ALL bots" listing.

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: domain is explained with a concrete example ("eth_usdc") and fund_type is documented with its three permitted values. What it omits is the default behavior — the schema defaults fund_type to "standard" — so an agent reading only the description would not know the unfiltered default.

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

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

States a specific verb and resource ("Browse ALL bots fieldable in funds") and enumerates the subcategories it covers — platform bots, your own bots, open-sourced bots, directional building blocks — which implicitly distinguishes it from list_my_bots, list_open_source_bots, and list_directional_bots. The "same marketplace human managers see in the fund editor" framing pins down exactly which dataset this is.

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

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

Gives clear workflow context: filter by the fund type you intend to add to, because a bot not listed for that fund type will be rejected by add_bot_to_fund. That tells the agent when to use this tool (pre-selection for fund composition). It stops short of naming alternatives or exclusions, notably the near-duplicate sibling get_marketplace_bots, which the agent must disambiguate on its own.

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?

No annotations are supplied, so the description must carry the behavioral burden. 'List' implies a read-only, non-destructive operation and the sentence reveals the metric set returned, but it says nothing about pagination, whether closed/stopped copies are included, or any auth/scope constraint on 'your'.

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

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

A single nine-word sentence with zero waste and the key qualifier ('your paper fund copies') front-loaded. It is a fragment rather than a sentence, which slightly weakens the opening.

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 an output schema present and no parameters, the description need not explain return values, and it doesn't. However, it leaves open whether stopped/closed copies appear and how this differs from the many per-copy get_* siblings, which is the main thing an agent needs to route 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 takes zero parameters, so the baseline is 4. The description adds no parameter filler, which is appropriate; there is simply nothing for it to disambiguate.

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?

Names the resource precisely ('your paper fund copies') and the payload it returns (live equity, P&L, allocation). The implicit verb is 'list', and 'your ... copies' distinguishes it from list_funds / get_fund, though the absence of an explicit verb keeps it from being maximally crisp.

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 and no named alternative. An agent cannot tell from the text whether to call this versus get_fund_copy_state, get_fund_live_pnl, or list_funds — it must infer the scope from 'your' 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 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. 'Without changing anything' usefully signals this is a side-effect-only append rather than a state mutation, but it says nothing about required permissions (manager-only?), public visibility, moderation, rate limits, or what happens on repeat posts.

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

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

A single sentence, front-loaded with the verb and resource, with zero filler. Nothing redundant is included.

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

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

An output schema exists so return values need no explanation, but for a write-to-public-surface tool with no annotations and zero parameter documentation, key information is missing: who may post, how visible the note becomes, and what headline/text constraints apply.

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% across three parameters, so the description must compensate and does not. It never explains fund_id, text, or the optional headline (empty-string default), nor any length or format constraints on the log body.

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 (post) and resource (fund's public manager's log), and the clause 'without changing anything' separates it from state-mutating siblings like update_fund_weights or set_manager_profile. It does not explicitly name the read counterpart get_fund_log, so sibling differentiation is only partial.

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 statement of when to use this tool versus alternatives such as get_fund_log or set_manager_profile. Usage is only inferable from the verb 'post', and no prerequisites, exclusions, or conditions are given.

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

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

With no annotations, the description carries the full burden and does disclose read-only semantics ('Read'), newest-first ordering, cursor-based paging ('pass the last post's id'), and the shape of returned posts. It omits auth/permission or rate-limit context, keeping it from a 5.

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

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

The opening sentence is front-loaded and precise, but a large middle block enumerates every returned field even though an output schema exists and makes that list redundant. It is organized but spends space on information the structured output already provides.

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

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

Given an existing output schema, the return-field details are not strictly necessary, but parameters are fully explained and the read-only, ordered, paginated nature of the call is clear. It is essentially complete for a read-only listing tool, with only minor gaps like auth context.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: limit is given a range and default, before is explained as a cursor using the last post's id, fund_id as a single-fund restriction, and tab as an enum with meaning for both 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?

States a specific verb and resource ('Read the Explorer timeline') plus precise scope ('every public fund move and post, newest first'). The wording distinguishes it from sibling feeds like read_wire by calling out the Explorer timeline and the public fund-move/post content.

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

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

Explains the two tab modes ('all' vs 'following') and how fund_id/limit/before narrow results, which implies usage. However, it never names when to prefer this over siblings such as read_wire, nor does it state 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 and does disclose the safety profile implicitly ('Read'), the strict scoping to actor="wire", and the exact return shape (headline + 1-3 sentence digest). It does not mention ordering/recency or volume relative to the hourly cadence, which matters for interpreting 'limit'.

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

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

Front-loaded with the definition, then scope, then usage, then the single arg. The Python-style 'Args:' block is slightly redundant with the schema but short enough to earn its place.

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

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

An output schema exists so return values need not be spelled out, yet the description still sketches them helpfully. For a one-param read tool, the only real gap is freshness/ordering semantics of the digest.

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

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

Schema coverage is 0%, so the description must compensate — it does, explaining that limit is the max number of wire posts and restating the default of 10. Nothing about ordering of the returned selection, but the semantic is otherwise clear.

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 (Read) and resource (the platform Wire), and defines it as 'the hourly AI crypto-news digest.' The clause 'Returns only the Wire's own posts (actor="wire")' implicitly separates it from the broader feed siblings (read_feed, get_replies), though it never names them.

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