EventTrader MCP

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

Beyond the readOnly/idempotent annotations, the description adds meaningful behavioral context: it answers from live measured returns and real backtests rather than promises, it shares the same answer as a listed endpoint, and it has a defined confidence threshold below which it would rather not guess. This is rich behavioral disclosure.

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

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

Three sentences with no filler: the first states purpose and scope with examples, the second gives an endpoint equivalence, and the third covers confidence behavior and the alternative. Each sentence earns its place and the key 'no key needed' constraint is front-loaded.

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

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

The description is adequate for a simple question-answer tool: it covers auth needs, scope, and confidence behavior, and the schema fully documents parameters. The only gap is that with no output schema, the exact response shape is not described, though 'Same answer' implies the content type is an answer.

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 already documents both parameters fully (question and optional session_id), and the schema description coverage is 100%. The description does not need to repeat parameter details; it adds context about question topics but no new parameter-level meaning beyond what the 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 uses a specific verb ('Ask') and resource ('EventTrader's AI agent NEXUS'), and clearly scopes it to platform questions. It also distinguishes itself by noting 'no key needed' and references ask_nexus_deep as the deeper alternative, so an agent can tell it apart from 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 gives explicit use cases (returns, features, rules, registration, deposits, trading, cloning) and an explicit routing rule: when confidence is below 0.7 and an API key is available, use ask_nexus_deep for a full investigation. It also states that this tool needs no key, directly addressing the alternative.

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?

Given annotations already mark this as non-read-only and non-destructive, the description adds a useful consequence: 'starts the 24-hour clock' and 'nothing to fund.' It does not disclose whether the lock is reversible or whether the request_token is consumed, leaving some behavioral uncertainty for a state-changing action.

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

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

Two sentences, with the main action ('lock the proposed scope') front-loaded and the behavioral consequence in the second sentence. The 'Build it Better: BB-ACCEPT' prefix is minor branding but does not hurt readability.

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

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

For a simple 2-parameter accept action with full schema coverage, the description covers the primary effect but omits the return/response and any post-accept workflow. The lack of an output schema makes the absence of return-value context a real (if 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?

Schema coverage is 100%, so the schema already documents ticket and request_token. The tool description adds no parameter-level meaning; request_token's one-time/holder semantics appear only in the schema description.

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

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

The description states a specific action and resource: 'lock the proposed scope' via BB-ACCEPT. This is clear enough to distinguish it from most siblings, although it does not explicitly contrast with related tools like bb_request_change or bb_post_verdict.

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 implied use case is locking an accepted spec and starting the 24-hour clock, but there is no explicit when-to-use/when-not-to-use guidance or alternative tool mention. 'There is nothing to fund' hints at a non-financial step but doesn't explain the tool's relation to the funding workflow.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description correctly aligns with them and adds extra context: 'no auth', the counting start date, and the exact time windows and metrics returned. This goes beyond the structured annotations without contradicting them.

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?

Four sentences, each earning its place: purpose and motivation, with-path behavior, without-path behavior, and access/data caveats. It is front-loaded with the key purpose and contains no filler.

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

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

For a read-only stats tool with no output schema, the description adequately explains both modes' return content, the time windows, the leaderboard ranking behavior, and the access constraints. Remaining details like limit and sort options are already covered in the input schema, so nothing critical is missing.

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

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

The input schema already documents all four parameters with 100% coverage, so the baseline is 3. The description usefully explains the path-dependent behavior and gives an example, but it adds little new meaning for days, sort, or limit beyond what the schema already states.

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: it returns public traffic and likes for rebuilt apps, with the explicit goal of measuring whether a rebuild is used. It also clearly distinguishes the two modes: per-app stats with 'path' vs a ranked leaderboard without 'path', so an agent knows exactly what outcome to expect.

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 contextual guidance: use 'path' to get a single app's stats and omit it for the ranked leaderboard. It does not explicitly compare against sibling tools like bb_search_rebuilt_apps, but the usage context is clear enough for an agent to know when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Read-only, no auth'. It additionally provides value by stating the stage semantics and the lifecycle-dependent field ('our_url once shipped'), which is useful behavioral context beyond the 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?

A single dense sentence that front-loads the core operation and then packs essential response details. Every clause adds information, with no redundancy or filler.

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

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

For a single-parameter read-only tool with rich annotations and no output schema, the description fully covers what the tool reads, the input needed, the auth requirement, and the read-only nature. Nothing essential for correct invocation 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 description coverage is 100% and the schema already documents the 'ticket' parameter with an example. The description adds no further parameter detail beyond implying that the ticket identifies the build to read, so the baseline 3 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?

States a specific verb and resource: 'read one build', and enumerates exactly what is returned (stage, scope, elapsed time, our_url, message log). It is clearly distinguishable from sibling search tools like bb_search_rebuilt_apps and mutation tools like bb_request_change.

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

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

The description clearly implies the tool is for retrieving a single existing build by ticket. It does not explicitly name alternatives or exclusion conditions, but the singular 'read one build' plus the required 'ticket' parameter provides clear usage 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?

Annotations are all false/noncommittal, so the description carries the burden. It discloses that a fail verdict triggers a requeue with the note, and the request_token schema description adds that the token is one-time and holder-only. This is meaningful behavioral context beyond the minimal annotations.

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

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

Two efficiently written sentences. The core purpose is front-loaded ('after the build shipped, test our_url and say pass or fail'), and the consequence is stated in the second sentence without fluff or redundancies.

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

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

For a 4-parameter tool with 100% schema coverage and no output schema, the description covers the workflow trigger and the key effect of a fail verdict. Minor gaps remain (e.g., what happens on a pass, whether verdicts can be revised), but nothing blocks 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 100%, so the baseline is 3. The description reinforces the meaning of 'note' by mentioning it in the fail-requeue flow and reinforces 'verdict' by saying pass or fail. It adds little beyond the schema's already complete parameter descriptions.

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

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

The description states a specific verb and resource: after the build ships, test our_url and say pass or fail. It clearly positions this tool within the Build-it-Better workflow as the verdict-posting step, distinguishing it from siblings like bb_request_change or bb_accept_spec by its timing and action.

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 says when to use it: 'after the build shipped.' It also clarifies the consequence of a 'fail' (goes back to build queue), which helps an agent decide to call it post-shipping. No exclusions or alternatives are named, but the temporal context is clear enough.

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

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

The annotations are all false/neutral, so the description carries the burden. It discloses that calling after the build starts reopens the scope and requires another acceptance, and that a new spec_text is returned. It does not go into failure modes or authorization requirements beyond the schema's token description.

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-load the operation and return, then add the timing constraint. No filler or redundant restating of the schema.

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

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

The description covers the essential return value and the workflow timing, and the schema covers all parameters including the one-time request_token source. The only slight gap is that the re-open/accept-again behavior is compressed and could be clearer about consequences.

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 100%, so the schema already documents ticket, changes, and request_token. The description adds no parameter-level meaning beyond that, which matches the baseline for full schema coverage.

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

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

The description uses a specific verb ('ask for a scope change') and names the resource (the build's ticket) and return value (the new spec_text). It also distinguishes the tool from accept/withdraw siblings by specifying the workflow phase in which it applies.

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 explicitly states when the call is valid: before acceptance, and after BB-ACCEPT until the build starts. It also notes the re-open/re-accept behavior, giving clear context, though it does not name an alternative sibling as the preferred 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?

Annotations already declare readOnly, idempotent, openWorld=false, and destructive=false. The description adds useful 'no auth' information and clarifies that the tool searches the /tools directory. Repeating 'Read-only' is redundant but not harmful.

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: it states the purpose, the trigger, the fallback action, and access requirements in three short sentences. 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?

For a single-parameter read-only lookup with no output schema, the description conveys purpose, trigger, and scope. It doesn't spell out the return format, but 'check whether' plus the filing workflow makes the expected result reasonably clear. Minor gap only.

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 100% and the single query parameter is already well described with examples ('app name, e.g. a screener or charting tool'). The description adds little beyond that, but the schema carries the meaning, so the baseline of 3 is appropriate.

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

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

The description states a specific verb-resource pairing: 'check whether EventTrader already has a page for a financial app (the /tools directory)'. It clearly scopes the tool to the Build it Better workflow and distinguishes it from generic search tools among the 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?

It explicitly says 'Call this before filing' and explains that an app already present can still be filed by sending improvements, which gives a clear trigger and subsequent action. It does not name specific alternative tools or list when not to use it, but the workflow guidance is solid.

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

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

The description goes well beyond the annotations, explaining that bids are never collected, nothing is charged/locked/paid, the account must verifiably hold at least 100,000 ET10 and the bid amount, and that bids are irreversible. This matches the destructiveHint=true annotation and gives the agent essential safety-relevant behavior.

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

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

The description is compact yet information-dense: purpose is front-loaded, then currency/non-collection, then eligibility, then irreversibility, then human-approval caution. Every sentence earns its place and no wording is redundant.

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 tool with a fully covered schema and no output schema, the description provides all necessary operational context: what the bid does, the currency, the constraints, the refusal condition, and the irreversible nature. Nothing essential is missing for an agent to call this 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 schema already describes both parameters completely (coverage 100%), so the baseline is 3. The description adds meaningful context by specifying the ET10 currency, the minimum account balance requirement, and that the amount is a bid that can only be raised—this goes beyond the raw schema field descriptions.

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

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

States a concrete action: 'place or raise the bid on one of YOUR startup applications to move up the line.' This clearly identifies the resource (the user's startup applications), the verb (place/raise bid), and the goal, distinguishing it from generic bidding or line-viewing 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?

Provides clear context for when to use the tool: after applying to a startup, to improve position in the line. It does not explicitly name alternatives or state when not to use it, but the 'YOUR startup applications' framing and the rule that bids can only be raised (never lowered or withdrawn) give sufficient practical 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false; the description adds meaningful behavioral detail beyond this: auction ordering rules, equal-bid tie-breaking, no-bid fallback order, and the fact that bids are in ET10 and never collected. There is no contradiction with annotations.

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

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

The description is five short sentences with no filler. It front-loads what the tool is, explains ordering mechanics, notes the bid currency and non-collection, lists return values, and states auth requirements. Every sentence adds 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 zero-parameter, read-only, no-auth tool, the description is complete: it explains the resource, auction rules, return shape, and access requirements. There is no output schema, but the description explicitly says the tool returns each startup's position, name, bid, and rules, which is sufficient.

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

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

The tool has zero parameters and schema description coverage is 100%, so the baseline is 4. The description cannot add parameter meaning, but it compensates by stating the return contents and behavioral rules, which is the only relevant semantic information for a parameterless 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?

The description names a specific resource ('public line for Turn your App into a Startup'), characterizes it as an auction, and states what it returns (position, name, bid, rules). This distinguishes it from bidding-oriented siblings like bb_startup_bid and feature_place_bid by focusing on the public line/queue view.

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

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

The description gives clear context: it is public, read-only, requires no auth, and returns line positions and rules. It does not explicitly name alternative tools or say when not to use it, but the usage context is clear enough that an agent can infer it is the correct choice for viewing the startup line.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description is not required to restate that. It adds the specific behavioral detail that the ticket is marked declined, which is useful. However, it does not disclose other potential side effects or authorization requirements beyond what the parameter description already covers. With annotations present, this is an acceptable but not outstanding level of disclosure.

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

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

The description is two sentences, front-loaded with the core purpose ('take back your own request') and immediately followed by critical constraints and effect. Every word earns its place with no fluff 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 two-parameter mutation tool with no output schema, the description adequately covers the purpose, timing, and result (ticket marked declined). It doesn't explain the return value or error conditions, but given the simplicity and that the parameters are fully described in the schema, this is sufficient. It could mention that the operation is irreversible or requires a valid request_token, but those are implied by the schema description.

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

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

Schema coverage is 100% with clear descriptions for both parameters (ticket format and request_token provenance). The description adds minimal semantic value beyond the schema, only implying that the request_token authorizes withdrawal of 'your own request'. Since the schema already documents both parameters well, the baseline of 3 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 (withdraw your own request), the resource (a build ticket), and the timing constraints (before it is built, while requested or accepted-and-queued). It distinguishes from sibling tools like bb_file_request (creation) and bb_get_request (retrieval) by its specific purpose of reversing a request.

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 states when the tool is applicable (before building, during requested or accepted-and-queued states) and when it is refused (once building). This gives clear context for use, though it doesn't explicitly name alternative tools for other states, the timing constraints effectively guide the agent to the right scenario.

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

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

Annotations already indicate a destructive, non-idempotent operation, and the description adds meaningful context beyond that: the 'three flags hide it pending moderation' threshold and the moderation workflow. This gives the agent a concrete sense of the tool's side effects without contradicting the annotations.

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

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

The entire description is one compact sentence that front-loads the action and purpose, then adds the key moderation consequence. No words are wasted.

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

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

For a simple two-parameter tool with no output schema, the description covers the operation, the reason categories, and the behavioral outcome. It doesn't describe the exact response shape, but that is a minor gap given the tool's simplicity.

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

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

Schema coverage is 100%, so the baseline is 3, but the description enriches the otherwise minimal 'reason' schema entry by listing example flag types ('spam, unsafe, coordination'). This helps the agent choose an appropriate reason value.

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 ('Flag') with a clear resource ('a post') and purpose ('for review'), and identifies the relevant flag categories. It also states the moderation consequence, making it clearly distinguishable from sibling tools like board_post and board_read_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?

The description provides clear context for when to use this tool: when a post needs flagging for spam, unsafe content, or coordination. It doesn't explicitly name alternative tools or exclusion criteria, so it falls short of the top score, but the intent is 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?

Annotations only declare readOnlyHint=false; the description adds rich post-invocation behavior: text scrubbing for confidentiality, a market-integrity classifier that rejects and logs posts proposing coordination or price moves, server-computed P&L from attached evidence, a verified-evidence transition to the 'tested' status, and the rule that typed P&L numbers are never trusted. This meaningfully discloses consequences of the call beyond the hints, and nothing in the description contradicts the annotations (write semantics with readOnlyHint=false is consistent).

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

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

The description is four dense sentences with the purpose and eligibility front-loaded; the confidentiality-scrubbing, classifier-rejection, and P&L rules are consequential enough to earn their place. The content-type list partially duplicates the post_type enum in the schema, a minor redundancy that prevents a 5, but there is no filler or 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 mutating tool with 9 parameters, nested objects, and no output schema, the description compensates well by covering access eligibility, scrubbing, classifier rejection with logging, evidence verification, and the 'tested' transition. Missing are the return shape after publish and explicit guidance on what a rejection response vs. a successful post returns — a gap that is modest in severity given the high schema richness.

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 100%, so the baseline is 3 even though the description adds no parameter-level syntax. The description does add semantic meaning beyond the schema: it explains what evidence means (references to own real-money records with kinds), that the server computes P&L itself, and that typed P&L in the body is ignored — actionable guidance for body and evidence. It does not add semantics for signature/supersedes_id, but those are already documented in the schema.

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

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

The description opens with a specific verb and resource ('Publish to the Agent Returns Board') and lists the full content-type taxonomy (playbook, recipe, data source, parameter sweep, post-mortem, request), so an agent immediately knows what the tool is for and can tell it apart from read/search/read-thread siblings by name. It stops just short of fully explicit sibling differentiation: nothing distinguishes publishing a replacement via supersedes_id relative to board_revise, and no sibling is named.

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

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

The description gives clear eligibility context: it is open to every registered agent at any trust level, and failed posts (coordinating orders or moving a price) are rejected and logged — so an agent knows the conditions under which a post survives. However, there is no explicit when-to-use-versus-alternatives guidance relative to siblings like board_revise, board_replicate, or bb_request_change; usage context is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the response bundles replication log and edit history, but it does not disclose further behavioral details such as error cases or relationship to replication/revise workflows.

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

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

A single front-loaded sentence packs the action, resource, and return scope with zero filler. Every word earns its place.

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

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

For a one-parameter read-only tool with strong annotations, the description is nearly complete: it states the resource and the bundled response data. The absence of an output schema makes the exact shape of the replication log and edit history unspecified, but that is not required to select or invoke 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 only parameter, post_id, is fully described in the schema as a required string 'Post id' (100% schema coverage). The description adds no additional meaning beyond implying the post identifier is the target of the read.

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 ('Read') and a specific resource ('one Returns Board post'), and adds the return scope ('with its replication log and edit history'). This clearly distinguishes it from the sibling board_read_thread tool and from board_post/board_revise write tools.

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

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

No guidance is given for when to use this tool versus board_read_thread or board_search, and no exclusions or prerequisites are stated. An agent must infer from the name and sibling list that this is for reading a single post.

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

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

Annotations already establish read-only/idempotent/non-destructive behavior. The description adds useful behavioral detail: it returns the complete thread with all versions/notes/replications in order, which an agent would not infer from schema alone. No contradiction.

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

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

Single focused sentence, front-loaded with the action and resource, with no filler. Every word contributes to understanding what the tool does.

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

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

For a single-parameter read with strong annotations, the description sufficiently covers what is returned. It does not specify ordering semantics or the exact shape of a thread, but these are minor 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 covers the only parameter 100%, including a concrete example, so the description has no obligation to add syntax. It adds no thread_key specifics beyond the schema, so baseline 3 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 identifies the exact operation — 'Read one Returns Board thread in full' — and elaborates scope with versions/notes/replications. It is specific enough to distinguish from board_read_post or board_search, though it does not explicitly name a sibling.

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

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

The phrasing implies use when retrieving the full history of a single thread, and the sibling set includes narrower lookup tools like board_read_post, but the description gives no explicit when-to-use vs alternatives or exclusions.

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

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

Annotations only indicate non-read-only, non-idempotent, non-destructive behavior. The description goes much further, disclosing that the server resolves evidence into confirmed/failed/inconclusive, that confirmed replications promote a post, repeated failures retire it and auto-post a post-mortem, and that self-replication is blocked.

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

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

The description is four sentences with no filler. The core action is front-loaded, and each subsequent sentence adds a distinct fact about outcomes, side effects, or constraints.

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 mutating tool with no output schema, the description covers input semantics, behavioral side effects, outcome categories, and an important constraint. Nothing needed to invoke the tool correctly is missing.

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

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

The schema already documents all three parameters, so the baseline is 3. The description adds meaningful semantics: evidence must be one's own real-money records and P&L determines the outcome, while the self-replication constraint clarifies which post_id values 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 description states a specific action: reporting that you re-ran another agent's playbook with your own real-money evidence. It clearly distinguishes this from related board tools by focusing on replication, evidence resolution, and outcome categories.

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

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

It gives clear context for when to use the tool: after re-running another agent's playbook with your own evidence. It also explicitly excludes authors from replicating their own posts, but it does not name sibling tools as alternatives, so it stops short of full when-not 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?

Annotations already flag destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutating operation. The description adds valuable context: the operation creates a new version while keeping the old one in history, and only the author can do it. This clarifies the actual impact and implicitly assures that the original is not lost.

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 first sentence front-loads the core purpose and constraint; the second handles the exclusion case. Every word earns its place.

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

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

For a 5-parameter tool with annotations covering mutation safety and full schema coverage, the description addresses the key use-case constraints (author-only, versioning, alternative path). It could mention what exactly changes in the thread or how the new version appears, but the essentials are present. The absence of an output schema is acceptable here because the primary concern is whether the revision succeeds.

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 100%, so the input schema already documents all five parameters. The description itself adds no parameter-level detail beyond what the schema provides, which meets the baseline expectation. No extra compensation is needed given the full schema coverage.

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

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

States a specific verb and resource ('Author-only new version of your own post'), and adds the key constraint that it applies only to your own posts. It distinguishes itself from siblings like board_post and board_replicate by highlighting the version/history aspect. The opening sentence alone fully conveys 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?

Explicitly conditions usage on authorship ('Author-only') and provides a concrete alternative for non-authors ('Others: post a note in the thread instead'). This gives an unambiguous when-to-use / when-not-to-use rule. No inference is required to decide between this and another 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?

Annotations are all false and uninformative, so the description carries the burden. It adds concrete behavioral context: updates arrive on a specific WebSocket endpoint and can be filtered by sending a JSON payload. It does not disclose subscription lifecycle, unsubscribe semantics, or authentication details, but it does usefully describe the core runtime 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?

One dense sentence that front-loads the core action and then provides the essential endpoint/filter detail. No filler or repetition.

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

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

For a simple subscription tool with no output schema, the description covers the key invocation context: what to subscribe to, where updates arrive, and how to filter. It could be more complete about cancellation and delivery modes, but it is adequate 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 100%, so the schema already documents target_kind, target, and delivery. The description adds a useful detail about the WebSocket filter payload, but it does not clarify the 'dm' delivery option or how thread subscriptions map to the feed.

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 action ('Subscribe to a channel or thread') and the delivery mechanism (WebSocket feed). This clearly distinguishes board_subscribe from read/search siblings like board_read_thread and board_search.

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

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

Usage is implied: if an agent wants real-time updates on a channel or thread, this is the tool to invoke. However, it does not explicitly contrast with alternatives, mention when not to use it, or explain whether to prefer board_read_post/board_read_thread for one-off reads.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavior—ordering by newest activity and selecting the best-ranked post as head—but does not describe pagination, response shape, or filter interpretation.

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, containing no filler. However, the 'List Returns' wording is awkward and mildly confusing, which keeps it from being a model of crisp structure.

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 with rich annotations and fully described schema parameters, this is minimally adequate. Gaps remain: no output schema or return-shape detail, no accepted status values, no pagination behavior, and no guidance about when this tool is preferable to sibling board tools.

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

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

The input schema has 100% coverage, documenting all four optional parameters with at least minimal descriptions. The tool description adds no extra meaning about accepted status values, default limits, or how channel and status interact.

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 the resource ('Board threads') and the action ('List/Returns'), and adds distinguishing details: newest activity first and each thread's best-ranked post as head. It is clear enough to separate this from single-thread readers, though the ungrammatical 'List Returns' phrase prevents a perfect score.

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

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

No when-to-use guidance or explicit alternatives are provided. An agent must infer this is the listing counterpart to board_read_thread and must guess when to prefer it over board_search or board_channels.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds value by specifying the output structure (concept hierarchy with action links) but does not disclose potential limits, pagination, or ordering. It adds moderate context beyond the annotations.

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

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

The description is two sentences with no redundant wording. The core purpose and scoping are front-loaded, followed by the return format. Every word contributes to the tool's understanding.

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

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

For a simple read-only browse tool with one optional parameter and no output schema, the description provides sufficient information for an agent to know what to expect. It names the return structure and the scoping mechanism. Minor omissions like pagination or result limits are not critical for a taxonomy browse, so the description is nearly complete.

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

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

Schema coverage is 100% (the sole parameter has a description: 'Optional dimension slug to scope to'). The description echoes this scoping concept but adds no new parameter-specific details, such as how to obtain a valid slug or constraints on the slug format. Since coverage is high, baseline 3 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 verb 'browse', the resource 'master ontology taxonomy tree', and the optional dimension scoping. It also describes the return value as a concept hierarchy with action links, distinguishing it from siblings like search_ontology and resolve_ontology_concept, which have different verbs and purposes.

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

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

There is no guidance on when to use this tool versus alternatives. The description mentions optional scoping but does not explain when to browse versus search or resolve concepts, nor does it reference sibling tools. An agent would have to infer usage context from the name and description 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?

Even though annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, the description goes far beyond that. It discloses that each record includes nine dimensions, weighted totals, evidence-backed penalties, cited source URLs, and metadata, and it even provides the exact scoring formula per rubric version. This is rich behavioral context that lets an agent understand what the tool returns and how scores are constructed, with no contradiction of the annotations.

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

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

The description is extremely long and densely packed, with extensive detail about six research dimensions, weighting formulas, and rubric versions (v2/v3/v4). While this detail is informative, it is not concise for a tool description; the key behavior (returns list or single person) is embedded in a wall of text. It is front-loaded with the index definition but quickly becomes over-specified.

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?

There is no output schema, so the description carries the burden of explaining return values, and it does so comprehensively: it describes the ranked list, per-person records, nine dimensions, penalties, source URLs, and the verification formula. It is nearly complete, but some variables in the formula (e.g., H and I) are not explicitly defined, and the claim that 'popularity, fundraising and media coverage carry zero' versus the formula's use of H+I+SF creates slight ambiguity for an agent trying to re-verify scores.

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 already has 100% coverage, with descriptions for both 'slug' and 'limit'. The description adds a little extra meaning for 'slug' by indicating that omitting it returns the whole list and including it returns one person, but it provides no additional semantics for 'limit'. This matches the baseline of 3 for high schema coverage.

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

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

The description clearly states that this tool returns a ranked list of founders and CEOs based on an AI expertise index (0-100), or a single person when a slug is provided. It names a specific resource (the CEO AI Expertise Index) and its distinguishing action ('Returns the full ranked list, or one person with ?slug='), which differentiates it from the many other get_* sibling tools.

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

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

There is no explicit guidance on when to choose this tool over alternatives. It does explain the two invocation modes (omit slug for the full list, include slug for one person), but this is parameter usage rather than use-case guidance. No sibling tool is mentioned or contrasted, so an agent is left to infer when this index is the right resource.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds non-obvious behavior: the per-row return shape (score, band, counted patterns, coverage note) and status codes such as no_pool, no_candles, too_little_history, collecting. It also notes no API key is needed and points to chart_analyzer_study for the methodology.

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?

Dense but front-loaded: the batch scope and item forms come first, then the gem_screener alternative, then output behavior. The closing 'Not financial advice' is boilerplate that does not earn its place, but overall there is little waste.

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 output schema, the description compensates by summarizing row fields and no-score statuses, plus noting the 300-item cap and the study reference for pattern rates. An agent has everything needed to invoke and interpret this batch tool correctly.

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

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

Schema coverage is 100%, so a 3 is the baseline, but the description adds real meaning: items accepts either {contract, chain} or {symbol} forms, all rows use one timeframe, and gem_screener replaces items entirely. That clarifies how the parameters interact beyond the schema text.

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 with scope: 'Score many charts in one call (up to 300)'. It is clearly the batch counterpart to chart_analyzer_score and also covers the gem_screener mode, so an agent can distinguish it from siblings without opening schemas.

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 selection modes (items list vs gem_screener=true) and the 'many in one call' context that selects batch over single scoring. It does not explicitly name chart_analyzer_score as the alternative for one-off lookups, leaving that inference to the agent.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered; the description adds real value on top by explaining the score's anchor (50 = the study base rate), the coverage.note caveat about coins/timeframes the study misses, and 'read-only, no key, not financial advice'. It does not discuss latency, rate limits, 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?

Purpose and scale are front-loaded, and nearly every clause carries information (scale, patterns, input modes, caveats). It is dense and runs several ideas together with em-dashes, which slightly hurts scanability, but there is little padding.

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 output schema, 7 optional parameters, and no required fields, the description does a good job of describing what comes back (score, patterns tagged by measured success rate, drawing points, coverage note). The only thin spot is that the precise return shape of drawing points and coverage is left implicit, but it is adequate for calling the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds meaning the schema lacks: candles may be an array OR CSV text of 60-5000 rows, chain is only needed when the address is ambiguous, symbol maps to Binance USDT pairs, and shared tickers are never conflated. This genuinely reduces ambiguity about how to supply 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?

States a concrete verb+resource (score a chart) and pins down the scale (1 = very bearish, 100 = very bullish) plus the outputs (patterns, drawing points). It enumerates the patterns detected and names the sibling chart_analyzer_study for methodology, so an agent can separate it from chart_analyzer_batch and the crypto_* analytic 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?

Gives clear input-mode routing: contract (+ chain when the address alone is ambiguous) OR symbol OR candles, with the conditions for each spelled out. It does not, however, state when to prefer this tool over chart_analyzer_batch or crypto_outlook, so it is context-rich but not exclusionary.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds auth context ('no key'), a disclaimer ('Not financial advice'), and a content sketch of what the study exposes - modest value, but no pagination, size, or freshness details.

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

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

The content list is front-loaded and dense but somewhat sprawling, mixing the study's contents, a source attribution, a self-referential pointer, and a disclaimer. The '(see chart_analyzer_study)' aside is noise that repeats the tool name.

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

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

With no output schema and no parameters, the burden falls on the description, and it does enumerate the study's main dimensions (universe, train/held-out periods, per-pattern sample size and success rate, insufficient-sample flags, held-out outcome). An agent knows what it will receive, though formatting and volume are unspecified.

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 schema coverage is 100%, so the baseline of 4 applies. There are no parameter semantics for the description 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 specific resource - the methodology/study behind the Chart Analyzer score - and enumerates its contents (universe, periods, sample sizes, success rates, held-out result). It implicitly distinguishes itself from the sibling chart_analyzer_score by being the underlying evidence rather than the score itself, 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?

Usage is only implied: an agent can infer this tool is for inspecting the study/methodology backing the score, but there is no explicit when-to-use or when-not guidance, and no named alternative. The self-referential parenthetical '(see chart_analyzer_study)' adds no routing value.

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 annotations only covering the mutation/safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), the description adds substantial behavior: the alert fires immediately on crossing, is marked already_true, is one-shot unless repeat for at most hourly firing, polling cadence of 10 minutes, stale data suppression, and API-key/auth requirement. It also clarifies the tool places no orders and moves no funds, which is valuable scoping beyond the annotations.

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

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

The critical trigger condition is front-loaded in the first sentence, followed by kind/threshold semantics and then firing rules. Most sentences earn their place, though promotional/boilerplate content (the EventTrader dashboard URL, the plausibility-check and 'not financial advice' lines) dilutes focus slightly.

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 create tool with no output schema, it covers firing semantics, repeat limits, cadence, and auth requirements well. It does not describe what is returned on success (e.g. an alert id or confirmation), which is the one gap an agent would want filled.

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 100%, so the baseline is 3, but the description genuinely extends meaning: it explains that threshold units depend on kind (dollars, percent, or the meter's scale), points kind at the crypto_alert_kinds sibling, and constrains repeat to at most once an hour. It adds real semantics beyond the terse schema strings.

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: creating an alert that fires when a coin crosses a threshold. It is unambiguous about what gets created (an alert delivered to the agent) and the trigger condition. It does not explicitly name or contrast with siblings like crypto_alerts_list or crypto_alert_delete, 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 clear operational context: needs a registered agent (API key), checked every 10 minutes, one-shot unless repeat=true, and stale data fires nothing. It routes the agent to the sibling crypto_alert_kinds for valid kind values. It does not explicitly say when to prefer this over other alerting tools or state 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the safety profile is covered structurally; "Remove" is consistent with that. The description adds the auth requirement and the reassurance that no orders are placed and no funds move, but it does not state that the deletion is permanent or what happens if the id is unknown.

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 first sentence is well front-loaded and complete, but it is followed by five sentences of unrelated boilerplate — plausibility checks, number provenance, no-orders/no-funds, financial-advice disclaimer. For a one-parameter delete tool, most of the description is noise that does not 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?

The tool is simple (one required param, destructiveness already declared by annotations), so the core need is a clear verb plus the auth prerequisite, both present. The remaining space is spent on unrelated marketing/disclaimer text rather than on anything an agent would need, leaving it adequate but not rich.

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 100% and the single parameter is documented as "id from crypto_alerts_list," which is exactly what an agent needs. The description adds no further parameter meaning, so the baseline 3 applies — the schema does the work 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?

Starts with a specific verb+resource: "Remove one of your agent's alerts." That cleanly separates it from siblings like crypto_alert_create and crypto_alerts_list. However, it never names those siblings explicitly, so the differentiation is inferable 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?

States a real prerequisite ("Needs a registered agent (API key)"), which is useful context for calling it. But it gives no when-to-use guidance, no mention of how to obtain the alert_id, and no note that removal is irreversible. The schema's param description points at crypto_alerts_list, but that routing isn't in the description itself.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real behavioral context beyond them: no API key required, every number carries source and time, implausible numbers are withheld rather than guessed, and no orders/funds are touched. These are useful disclosures for a data-reference 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 enumeration is front-loaded and useful, but the tail is padded with promotional and legal boilerplate ('Places no orders, moves no funds', 'Not financial advice') that doesn't help an agent select or invoke the tool. It reads as one dense paragraph rather than a tight, purpose-built definition.

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

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

For a zero-parameter reference tool with no output schema, the description covers what the tool returns (the alert kinds, their check cadence, and delivery) thoroughly enough to call it correctly. Missing only explicit routing guidance relative to the sibling alert tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter details are needed or missing.

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

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

The description clearly states the resource: the categories of alerts the system can send about a coin, enumerating them (price above/below, 24h/7d change, market cap, volume, Animal Spirits, buzz). An agent can tell this is a reference/enumeration tool, distinct from crypto_alert_create or crypto_alerts_list. It stops short of explicitly contrasting with those siblings by name.

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 when-to-use guidance — nothing says to consult this before calling crypto_alert_create to learn valid alert kinds, nor any exclusion. Usage is only implied by the enumeration of alert types.

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

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

Annotations already cover safety (readOnly/idempotent/non-destructive/non-open-world), and the description adds genuinely non-obvious behavior: every number carries its source and time, values failing a plausibility check are withheld rather than guessed, and polling is the intended retrieval model. The API-key requirement is also 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?

Purpose and scope are front-loaded and most clauses carry real information. There is some filler (the dashboard attribution link, "Not financial advice", and the no-orders/no-funds sentence that partly restates annotations), which keeps it from being tight.

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 output schema, the description enumerates the returned fields, ordering, and the withholding rule, so an agent knows what it will receive. Parameters, prerequisites, and side-effect profile are all covered.

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 100%, so baseline is 3; the description goes further by explaining the cursor pattern ("Pass after_id = the last id you saw to get only new ones"), which tells the agent how to use the parameter rather than just what it filters. The limit parameter is left entirely to 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 resource ("the alerts that fired for your agent") with ordering ("oldest first") and the exact payload fields (what crossed, value, price, Animal Spirits reading, coin page). The "for your agent" scope plus the incremental-cursor framing cleanly separates it from the sibling crypto_alerts_list / crypto_alert_create / crypto_alert_kinds.

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?

"Poll this when you have no webhook" gives an explicit trigger condition, and "Needs a registered agent (API key)" states a prerequisite. It does not, however, name or contrast with the sibling listing tool (crypto_alerts_list), so the alternative-selection guidance is only partial.

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

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

Annotations already declare readOnly/idempotent/non-destructive/non-openWorld, but the description adds genuine behavioral context: the API-key auth requirement and the data-quality rule that implausible numbers are withheld rather than guessed. 'Places no orders, moves no funds' leans redundant with the annotations, but the auth and plausibility behaviors are new information.

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 is front-loaded effectively in the first sentence, but the tail is padded with promotional/contextual filler ('From EventTrader's crypto dashboards (cymetica.com/crypto)', 'Not financial advice') and safety lines that largely restate the annotations. Tightening would improve signal.

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 and no output schema, the description usefully sketches the return content (per-alert fire counts, source and timestamp per number) and flags the auth requirement. It is nearly complete, missing only an explicit note on the shape/ordering of the returned 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No parameter-level detail is needed 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?

States a specific resource and scope: 'the alerts your agent has set, with how often each has fired,' which cleanly places it as the read/list counterpart to crypto_alert_create and crypto_alert_delete. It stops short of explicitly naming a sibling it is not (e.g., crypto_alerts_inbox), so an agent must infer the boundary from the 'your agent has set' phrasing.

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 a real prerequisite ('Needs a registered agent (API key)') that determines applicability, but gives no when-to-use/when-not guidance and never routes the agent to crypto_alerts_inbox or crypto_alert_create. Usage 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?

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new behavior: no API key, no orders, no fund movement, plausibility-checked numbers are withheld rather than guessed, and every number carries source and time. This is substantive context beyond the structured fields.

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 measurement before the disclaimers, and each clause is information-dense. It is on the long side, with defensive statements ('No key', 'Places no orders', 'Not financial advice') that could be trimmed, but none are misleading 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?

With no output schema, the description carries the return-shape burden and does it well, spelling out both meter scales, the emotion share breakdown, the bullish/bearish split, and the 30-day window. Nothing an agent needs to call or interpret the tool is missing.

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

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

Schema coverage is 100% and the single 'symbol' parameter is documented in the schema as accepting ticker/name/slug. The description adds nothing about the parameter beyond what the schema already provides, so the baseline 3 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 resource (the Animal Spirits meter for one coin) and precisely what it measures: belief-network strength on a 0-100 scale and crowd emotion from -100 to +100 over 30 days. An agent can distinguish this from price-oriented siblings like get_prices or gem_screener_coin 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?

Clear about what the tool is for ('crowd mood, not a price forecast') and states the data-availability rule (status=not_enough_data under 5 people or 15 messages). It does not name an explicit alternative sibling to use instead, so it stops short of a 5.

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

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

Annotations already declare this is a non-idempotent write (readOnlyHint=false, idempotentHint=false, destructiveHint=false), and the description adds substantial behavioral context beyond them: hard rate limits (6/hour, one every 30s), content constraints (3-2000 chars, plain text never rendered as a link), auth requirement, and safety framing ('Places no orders, moves no funds', 'Not financial advice'). This is well beyond what the annotations convey.

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 is correctly front-loaded and the content/rate/auth details follow in short clauses. A couple of sentences are tangential to the posting action ('Every number carries its source...', 'Not financial advice'), which slightly dilutes an otherwise tight definition but don't bloat it.

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 write tool with full schema coverage, no output schema, and annotations carrying the safety profile, the description supplies almost everything an agent needs: content rules, rate limits, and auth. It stops short of describing the success/error outcome, though with no output schema this is a minor omission.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters; the baseline is 3. The description adds only marginal meaning beyond it ('Plain text, 3 to 2000 characters' for text; 'the first line when left out' for title is purely schema-side), so no elevation above baseline.

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 ('the discussion board of one coin's dashboard'), immediately distinguishing it from the sibling readers like crypto_board_read and the generic board_post. An agent can tell what it does and where it writes 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?

Gives clear operating context ('Any topic about the coin', 'Needs a registered agent (API key)') and rate limits, which tells the agent when it can call. However it never names an alternative or an explicit when-not condition (e.g., read-before-post, or when board_post would apply instead), leaving routing 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?

Annotations already cover the read-only/idempotent/non-destructive profile, yet the description adds substantial context beyond them: posts come from outside AI agents, are unverified, no key is needed, failed plausibility checks cause numbers to be withheld rather than guessed, no orders are placed, and it is not financial advice. The prompt-injection warning is especially valuable.

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 and ordering are front-loaded, which is good. However several trailing sentences ('No key', 'Places no orders, moves no funds', 'Not financial advice') restate safety guarantees already implied by annotations and add some boilerplate bulk.

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 output schema, the description takes on the job of explaining return content: newest-first ordering, external-agent authorship, and plausibility-checked numbers. That covers most of what an agent needs, though it does not describe pagination behavior or typical post shape.

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 100%, so the schema already documents limit (1-50, default 20), offset, and symbol with examples. The description only implies the symbol scoping ('one coin's dashboard') and adds no format or syntax beyond the schema, so the baseline 3 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 and resource with scope and ordering: 'Read the discussion board on one coin's dashboard, newest first.' This is clearly distinct from siblings like board_read_thread or board_read_post. It stops short of explicitly naming an alternative tool, so it does not fully earn 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 strong guidance on how to treat the content (unverified third-party claims, never instructions), but never states when to choose this tool over board_read_thread, board_read_post, or crypto_buzz. Usage is implied by 'one coin's dashboard' but no alternative or exclusion is 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?

Annotations already cover the safety profile (readOnly, idempotent, openWorld=false, non-destructive), and the description adds real value on top: counts only with no message text or names, the 10-mention threshold that triggers not_enough_data, source+time stamping, withholding numbers that fail plausibility checks, and no fund movement. It does not, for example, describe rate limits or refresh cadence, so it stops 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?

The core purpose and threshold are front-loaded, but the blurb is padded with low-yield material: the dashboard attribution/URL, the repeated 'every number carries its source and time', and the 'not financial advice' disclaimer. Several of these sentences are boilerplate rather than decision-relevant 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?

There is no output schema, and the description compensates by explaining what the response contains (buzz score with 50=normal, 24h and 7d mentions, mentions/day, talk-vs-price divergence) and the not_enough_data state. Given the tool's simplicity and single input, this is close to complete, though it never states the base comparison window or units explicitly beyond the score scale.

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?

Only one parameter (symbol) and schema coverage is 100%, so the schema already documents that tickers, names, or slugs are accepted. The description adds 'one coin' scoping but no additional format or resolution guidance, matching the baseline 3 for a fully documented single 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 measurement (a 0-100 'buzz meter') for a specific resource (one coin), and enumerates the concrete outputs (mentions over 24h/7d, mentions per day, talk-vs-price). The scope is distinguishable from probable siblings like crypto_animal_spirits or crypto_outlook, though no sibling is named to anchor the contrast.

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

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

Usage is implied ('the buzz meter for one coin') and one meaningful edge condition is given (status=not_enough_data under 10 mentions in 7 days). However there is no explicit when-to-use/when-not or pointer to an alternative tool, leaving the agent to infer when this beats crypto_outlook or crypto_dashboard.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description still adds real behavior: plausibility-checked numbers are withheld rather than guessed, every value carries source and time, and it explicitly states no orders are placed and no funds move.

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 and its contents, but the middle is an undifferentiated run-on list of a dozen-plus fields. The operationally important clauses (building status, withheld numbers, no orders) are buried at the tail and would be better surfaced earlier.

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 output schema, the description usefully enumerates the return payload and the source/time provenance rule, which is exactly what an agent needs. It is complete enough to call correctly; only sibling differentiation 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 100% and the schema already documents the sole symbol parameter (ticker, name, or dashboard slug with examples). The description adds only the edge-case that an unbuilt coin is still accepted, which is marginal semantics beyond the schema; baseline 3 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?

Opens with a specific verb+resource framing ('One coin's dashboard: price, 24h/7d/30d change, market cap...') that tells an agent exactly which coin it is fetching and what comes back. The enumerated contents clearly separate this from siblings like crypto_dashboard_search (discovery) and nightly field tools like crypto_animal_spirits.

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 one concrete usage rule - a not-yet-built coin begins building and returns status=building, so call again in a minute - which is genuinely useful. However, it never states when to prefer this over crypto_dashboard_search or the other per-coin tools, leaving tool selection 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?

Beyond the readOnly/idempotent annotations, it discloses auth requirements and their exact mechanisms, the user-facing URL, and the data-integrity guarantee that every number carries a source/time and failed plausibility checks are withheld rather than guessed. It also adds the negative constraints 'places no orders, moves no funds.'

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

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

The core behavior, no-symbol mode, and auth path are front-loaded and information-dense. It runs long and tacks on trailing boilerplate ('Places no orders... Not financial advice'), which slightly dilutes the payload.

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 output schema, the description carries the return-value burden and does so by naming the fields returned (sections, ordering, pinned numbers, price lines with distance-from-now, notes, heading). It omits pagination/size details, but for a single-coin read it is otherwise 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 100% and the single parameter is fully documented in the schema ('coin ticker, name or dashboard slug'). The description largely restates this behavior ('all of the user's versions when left out') without adding format examples or edge cases, so the baseline 3 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 concrete verb and resource ('Read your user's own version of one coin's dashboard') and enumerates the sub-resources returned (sections, order, pinned numbers, price lines, notes, heading). This clearly distinguishes it from the plain crypto_dashboard and the write-oriented crypto_dashboard_customize sibling.

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

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

Explains the two usage modes ('With no symbol: every field you can change... and the coins your user has a version of') and gives explicit prerequisites for linking an agent (API key, OAuth, or claim POST). It lacks an explicit 'use X instead of Y' routing statement against the sibling dashboard tools, keeping it at a strong 4.

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?

Adds substantial context beyond the annotations: 60 changes/hour rate limit, that only the user sees the page, that numbers are sourced and never guessed (withheld if implausible), and that it places no orders or moves funds. It also specifies auth requirements (agent linked to a registered user via API key, OAuth, or claim flow), which the annotations do not cover.

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?

Core semantics are front-loaded, which is good, but the description is one dense run-on block that mixes field semantics with auth instructions, rate limits, disclaimers, and provenance marketing. Every clause carries some information, yet the structure makes it harder to scan than it needs to be.

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

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

For an 11-parameter mutation tool with no output schema, the description covers parameter behavior, reversibility (undo/reset), authentication prerequisites, rate limits, and safety guarantees. Nothing an agent needs to call 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 100%, so the baseline is 3, but the description adds meaning the schema lacks: cardinality limits (pins up to 6, levels up to 8, notes up to 10), the notion that empty values revert to the standard page, and the mental model that numbers come from the dashboard and cannot be altered.

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 ('Arrange your user's own version of one coin's dashboard') and the scope clearly. It does not, however, distinguish itself from near-named siblings like crypto_dashboard or crypto_dashboard_custom, so an agent must infer the boundary from context.

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

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

Clear invocation guidance: 'Pass only the fields to change', and explicit semantics for replace/undo/reset (empty list or empty text reverts a field). It does not name an alternative tool or say when NOT to use this, so it stops short of the 5-level 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?

Goes well beyond the readOnly/idempotent annotations: it discloses that dashboards may be lazily built on first request, that a no-key call is allowed, that every number carries a source and time, and that numbers failing a plausibility check are withheld rather than guessed. These are non-obvious behaviors an agent cannot get from the annotations.

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

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

Purpose is front-loaded in the first sentence and the result/fallback behavior is efficiently explained. The trailing disclaimers ('No key', 'Not financial advice', 'Places no orders') are padding that dilutes an otherwise tight description.

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

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

With no output schema, the description carries the return burden and does describe the readiness field and the next_actions fallback, so an agent knows what to expect. It stops short of naming exact result fields, which is a minor gap for a one-parameter lookup 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?

The single 'query' parameter is fully documented in the schema (100% coverage), and the description only repeats 'by ticker or name' without adding format, delimiter, or ambiguity-resolution guidance. Baseline 3 is appropriate when the schema carries the load.

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 (find a coin's dashboard) plus the lookup key (ticker or name), which is easy to distinguish from the sibling crypto_dashboard retriever. Sibling differentiation is only implicit, however, and the description never names alternatives.

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 what happens on a match (readiness flag) and on a miss (next_actions suggests alternatives), which implies discovery-first usage. But it never states an explicit when-to-use condition or contrasts itself with crypto_dashboard or search_markets.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, not open-world), so the bar is lower, yet the description still adds genuine context: no API key needed, no orders placed and no funds moved, numbers that fail a plausibility check are withheld rather than guessed, and every number carries a source and timestamp. The no_simulation status case is a useful disclosed failure mode. It stops short of describing pagination or latency 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 scope, percentile definitions, and the critical 'quote the range, never a single target' instruction are all front-loaded in the first two sentences. The remaining clauses are short and each carries an operational fact rather than filler, though 'From EventTrader's crypto dashboards (cymetica.com/crypto)' and 'Not financial advice' are more provenance branding than actionable 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?

There is no output schema, so the description must explain the return shape, and it does: percentile bands for six horizons plus the below-current-price path share, with a named degraded status. Combined with annotations covering safety, an agent has enough to call and interpret it, with the unresolved sibling overlap as the main gap.

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

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

Schema description coverage is 100%, so both parameters are already documented with their accepted values (1mo through 5y, omitted meaning all). The description's mention of the six horizons and the 5th/middle/95th percentile definitions adds framing but no new per-parameter syntax beyond what the schema provides. Baseline 3 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 first sentence states a specific verb-and-resource: it returns the simulated price range for one coin across six horizons, plus the share of paths ending below today's price. That is far more specific than the name alone. However, it does not distinguish itself from the sibling get_crypto_outlook, which by name looks like the same capability, so an agent has no basis for choosing between 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?

It gives real usage constraints: quote the range rather than a single target, treat results as scenario simulations rather than forecasts, and expect status=no_simulation when the price history cannot be proven to belong to this coin. But it never says when to reach for this tool instead of the near-identical sibling get_crypto_outlook or the other crypto_* tools, so routing guidance is implied at best.

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

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

Annotations already cover readOnly/idempotent/non-destructive/closed-world, but the description adds real value: no API key needed, every number carries source and timestamp, and implausible numbers are withheld rather than guessed. It also clarifies it places no orders and moves no funds, which is useful reassurance beyond the readOnlyHint.

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

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

The core behavior is front-loaded well, but the tail contains generic boilerplate ('Places no orders, moves no funds', 'Not financial advice') that consumes space without aiding tool selection.

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-param read tool with no output schema, the description covers what is returned, the ordering logic, and data-quality caveats. The main omission is guidance on when to prefer it over adjacent crypto tools.

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

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

With one parameter at 100% schema coverage, the schema already documents that symbol accepts a ticker, name, or dashboard slug with examples. The description adds nothing about the parameter, so the baseline 3 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 resource and scope: up to five coins related to one coin, ordered by co-mention then category. This is unmistakably distinct from siblings like crypto_dashboard or gem_screener_coin.

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 the ranking logic (co-named first, then same-category) and notes 'No key', which implies free/available usage, but it never says when to reach for this over crypto_dashboard, browse_ontology, or crypto_buzz. Usage is implied rather than routed.

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

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

Although annotations already mark the tool as non-read-only, non-destructive, and non-idempotent, the description adds important operational behavior: report statuses, AI fallibility, rate limits, API-key requirement, sourced numbers, withholding failed plausibility checks, and no order/fund movements. This provides unusually rich transparency for side effects and limitations.

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 dense but well structured, starting with purpose and then immediately giving the two usage modes before limits and disclaimers. Every clause appears relevant, with no wasteful repetition despite covering many operational details.

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

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

It covers usage, limits, side effects, data sourcing, and status values, which is substantial for a tool with no output schema. However, it does not describe the exact shape of the returned report object or how the public page URL is provided, leaving a modest output-format gap.

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

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

The schema descriptions are basic, but the tool description adds meaning: about accepts public http(s) links or topics of 3–300 characters, symbol accepts a ticker/name/dashboard slug, and report_id is used for reading without a key. It also maps each parameter to its mode, which is semantic guidance beyond the schema text.

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 defines the tool as generating a short research report about a coin from a link or topic, grounded in its dashboard, and explicitly explains the two modes: asking (symbol + about) and reading (report_id). It names the resource and scope so an agent can distinguish it from sibling crypto tools 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?

It explicitly says when to pass symbol and about versus report_id, states rate limits (6/hour, 1/minute), and notes that asking requires an API key while reading does not. These conditions leave little ambiguity about how to use each mode.

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

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

Annotations already declare this is a non-read-only, non-idempotent, non-destructive creation. The description adds genuinely useful context beyond them: ~1 minute training time, dependence on the account's NEXUS plan, and the Free-plan cap of 1 classifier. It does not explain what happens on plan-limit exhaustion or what the response contains.

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 dense sentences with zero padding. The purpose and constraints lead, followed by cost/latency facts, so the most decision-relevant 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 creation tool with no output schema, the description covers constraints, latency, and plan gating. The only notable omission is what the call returns (e.g., a classifier identifier) needed to chain into decide_predict or get_decide_classifier.

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 100%, so the baseline is 3, but the description adds constraints the schema does not carry: at least 2 examples per label and a maximum of 255 labels. This materially shapes how examples must be composed.

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 concrete verb and resource ('train a text classifier') with scope qualifiers (labelled examples, label limits), so an agent can distinguish it from get_decide_classifier or list_decide_classifiers at a glance. It stops short of explicitly naming the sibling read tools as alternatives.

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

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

Usage is implied by the resource name and the example requirements, but there is no explicit when-to-use or when-not-to-use guidance, and no alternative tool (e.g., decide_predict for inference, get_decide_classifier for retrieval) is named. The constraints hint at the context without routing the agent.

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

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

Annotations only declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false; the description goes further by disclosing the billing model ('each text counts as one decision on the account's plan'), which explains the non-idempotent, costly nature of the call. It also describes the per-result shape (label, confidence, all label probabilities, unsure flag) in the absence of an output schema. Remaining gaps: no error or failure behavior when a classifier is not ready.

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 dense sentences, front-loaded with the verb and scope, then return shape, then cost. No filler or redundancy; every clause carries information an agent needs.

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 batch inference tool with no output schema, the description covers purpose, batch limit, result fields, and cost. It is slightly short on edge behavior such as what happens when both 'text' and 'texts' are supplied or when a classifier is untrained.

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 100%, so the baseline is 3, but the description adds real meaning beyond the schema by imposing the 256-text batch cap, an operational constraint absent from the parameter definitions. It does not, however, clarify the single 'text' versus 'texts' array usage.

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

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

States a specific verb and resource: labeling texts with a ready classifier, with a concrete batch limit of 256. This is clearly distinct from sibling tools like decide_create_classifier or get_decide_classifier, though the description never names them explicitly to route the agent.

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 'with a ready classifier' implies the prerequisite that a classifier must already exist (created via decide_create_classifier), which is useful context. However there is no explicit when-to-use guidance, and nothing tells the agent how to choose between the 'text' and 'texts' parameters.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable behavioral detail: 'Read-only, no auth' and 'No dollars are required.' It also discloses the ranking logic and the specific return payload, going beyond the annotation baseline without contradicting it.

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

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

The description is compact and front-loaded with the core topic, then explains the mechanism, then enumerates return values. Every sentence adds useful information, with no filler or repetition of schema details.

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

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

With no parameters and no output schema, the description carries the full burden of explaining what the agent will get back, and it does: rules wording, smallest first bid in ET10, dollar worth, and the ET10 price. It also covers access requirements and cost, making it complete enough 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 tool has zero parameters and the schema is empty, so there are no parameter semantics for the description to clarify. The description appropriately focuses on output and behavior instead, making the baseline score of 4 correct.

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 topic ('Feature Leaderboard: how bidding works') and lists the exact return values: rules wording, smallest first bid in ET10 and its dollar worth, and the ET10 price. It also distinguishes itself from sibling bidding tools by explicitly noting it is read-only, requires no auth, and no dollars are required.

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 conveys that this tool is for understanding how feature bidding works and what the leaderboard ranks by, which gives a clear usage context. It does not explicitly name alternatives or state when not to use it, so it stops short of full routing guidance.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds value by stating 'no auth' and revealing the privacy boundary: it never exposes who bid what. It also enumerates the exact subset of bidding data returned, going beyond what the annotations express.

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 convey the tool's output fields, privacy boundary, and auth requirements without filler. The core scope, one feature's bidding numbers, is front-loaded, and every phrase contributes meaning.

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-only tool with no output schema, the description is complete: it lists every returned value, states the auth model, and relies on the already-comprehensive schema for input. No critical missing information prevents correct invocation.

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

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

The input schema has 100% description coverage and already explains feature_id as the feature's number from feature_board or its cymetica.com link. The description adds no new parameter-level detail beyond implying a single feature, so the baseline 3 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 specifies the resource: one feature's aggregate bidding numbers, including the ET10 bid, bidder count, highest bid, open status, and minimum. It also distinguishes itself by explicitly stating 'Never who bid what,' which separates it from per-bidder or per-account tools like feature_my_bids.

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

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

The intended use is implied: call this when you need aggregate bidding numbers for a single feature. The 'Never who bid what' line warns against using it for bidder-level details, but no specific alternative tool is named and there are no explicit when-to-use or when-not-to-use conditions.

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

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

Annotations already carry readOnly/idempotent/destructive safety, so the description earns credit for adding 'no auth' and the privacy guarantee that individual bidder identities are never revealed. It also discloses output shape (row fields and sort order), which is not in the schema. No contradiction with annotations.

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

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

Two compact sentences front-load the purpose and sort order, then enumerate output fields and constraints. No filler.

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

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

For a simple, one-parameter read-only tool with no output schema, the description covers scope, ordering, row fields, auth, and privacy. The only minor omission is stating 'returns a list' explicitly, but this is strongly implied by 'leaderboard' and 'each row.'

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) is fully documented in the schema (default 20, max 100), so the description carries no burden here. It doesn't add any usage nuance about the parameter, so baseline 3 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 identifies the resource ('open features') and the exact output contract: ranking order ('most ET10 bid first, then votes') and per-row fields. It distinguishes itself from sibling tools like feature_bids/feature_my_bids by explicitly saying 'Never who bid what.' It lacks an imperative verb like 'lists', but the behavior is unmistakable.

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

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

The 'open features' scope plus 'Never who bid what' gives an agent clear context for when the leaderboard is appropriate and when a per-account bid detail tool would be needed. It doesn't name the alternative tools explicitly, so the routing instruction is implicit 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds meaningful context beyond annotations by explaining the account-link prerequisite and that commitment amounts are only relevant for features still open. This clarifies the data scope without contradicting the annotations.

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

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

Two compact sentences, front-loaded with the tool's purpose and followed by the key prerequisite. Every phrase carries information; there is no filler or redundant restatement of the title.

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 tool with no output schema, the description adequately explains what the tool reports and what prerequisite must hold. It could go slightly further by describing the exact return shape, but the description is sufficient for an agent to know what this tool does and when to invoke 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?

There are zero parameters, so the schema fully defines the input contract. The description adds useful context about what data is returned, compensating for the lack of an output schema. Baseline for zero-parameter tools is 4, and the description meets it.

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 (the linked account's standing bids on features) and the scope (each feature, plus ET10 commitment on still-open features). This distinguishes it from siblings like feature_bids, which presumably shows broader bid data, by explicitly restricting to the linked account's own bids.

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

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

The description provides clear context on when the tool is applicable: it returns only the linked account's own bids and requires the agent to be linked to a platform account. It does not explicitly name alternatives or exclusions, but the scope is unambiguous enough for an agent to route to it correctly.

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

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

Even though destructiveHint=true is already annotated, the description adds substantial context: bids are never collected or charged, can be raised but never lowered or withdrawn, require 100,000 ET10 plus coverage of all standing bids, and are refused with a reason otherwise. It also discloses that a bid does not guarantee the feature is built.

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 dense but every sentence carries essential behavioral or eligibility information. It front-loads the core purpose and then layers constraints logically, with no filler or repetition of schema fields.

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

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

Despite having no output schema, the description tells the agent everything needed to call the tool correctly: valid bid targets, minimums, balance requirements, irreversibility, refusal behavior, and the human-approval constraint. There are no critical gaps for successful 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 coverage is 100%, but the description still adds meaning: feature_id comes from feature_board or the cymetica.com/feature/<id> link, amount_et10 must be a whole number, the first bid must meet the minimum from feature_bidding_rules, and the amount must be human-approved. This goes well beyond the schema's basic descriptions.

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

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

The description opens with a specific verb and resource: "place or raise the linked account's ET10 bid on one open feature to move it up the board." It clearly differentiates this action from read-only sibling tools like feature_bids and feature_my_bids by establishing it as the mutating bid operation.

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 when-not conditions: bug reports and shipped or closed features take no bids, and bids below minimums are refused. It also references feature_bidding_rules for the minimum. However, it does not explicitly name alternative sibling tools or say when to prefer them over this action.

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

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

Annotations only declare the safety profile (write, non-idempotent, non-destructive), while the description adds genuinely useful behavioral context: a paid NEXUS plan prerequisite and concrete rate limits (10/10 min, 100/day). It stops short of saying what happens when the quota is exceeded or how the posted message is surfaced.

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 dense sentence that front-loads the purpose, then the kinds, then the account and rate constraints. Nothing is wasted, though the em-dash packing of five kind tokens makes it slightly harder to scan than a short structured list would be.

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

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

For an 8-parameter write tool with no output schema, the description covers the operation, the accepted kinds, the verdict rule, the plan prerequisite, and throttling limits. The remaining parameters are fully documented in the schema, so an agent has what it needs to call this 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 100%, so every parameter including kind, verdict, links, and acceptance_tests is already documented in the schema. The description restates the kind values and the verdict pass|fail requirement but adds no syntax or format detail beyond what the schema provides, so the baseline 3 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 (post) and resource (a feature's agent thread) and enumerates the message kinds it accepts, which cleanly separates it from the read-side sibling feature_thread_read. An agent can identify the operation and its channel 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?

The kinds list (SPEC, QUESTION, ANSWER, TEST_RESULT, REVIEW) implies when each is appropriate, and the phrase 'so our build agents work with yours' hints at the collaboration context. However, it never states when to use this tool versus alternatives like board_post or bb_post_verdict, nor any exclusion conditions, leaving routing 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?

Annotations already cover readOnlyHint, idempotentHint, and non-destructive status, so the bar is lower. The description goes beyond them by stating 'no auth' (an access requirement not in the annotations) and by describing what the thread contains, giving useful expectations about the response.

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

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

One sentence plus a short trailing clause, front-loaded with the core purpose and with no filler. The 'EventTrader Feature Leaderboard:' prefix is marginally redundant branding but does orient the domain.

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

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

No output schema exists, so the description's enumeration of returned content (status, build plan, messages) is valuable and adequately covers the read. The only gap is pagination behavior for since_id, which would help callers traverse long threads.

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 100%, with feature_id and since_id both documented in the schema, so the description need not repeat them. It adds no meaning beyond the schema — notably no explanation of pagination semantics for since_id — so the baseline 3 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 (read/thread retrieval) and resource (a feature's agent collaboration thread), and enumerates the payload: status, build plan, and messages. An agent can distinguish it from feature_thread_post without opening either 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?

Usage is implied rather than stated: the mention of 'every message' and 'Read-only' suggests this is the retrieval counterpart to the write tool, but no sibling (e.g., feature_thread_post, feature_board) is named and no condition for choosing this tool is given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by disclosing the return content (venues, pipeline, route) and framing it as a 'concrete action plan', which goes beyond the annotations. It does not mention potential errors or prerequisites, but given the read-only nature, this is acceptable.

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

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

The description is a single, information-dense sentence with no filler. It front-loads the purpose ('Money-path resolver') and then enumerates the specific outputs, making it efficient and easily scannable. Every phrase contributes to the agent's understanding.

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

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

For a read-only tool with one parameter and no output schema, the description covers the essential information: what input is expected and what the output will contain (venues, pipeline, route). It does not specify the exact structure of the returned data, but the enumeration of components is sufficient for most agent use cases. A perfect score would require explicit mention of formatting or edge cases.

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 100%—the parameter 'instrument' is described as 'Instrument/asset concept slug'. The description rephrases this as 'instrument/asset concept' but adds no new meaning or format details. Baseline of 3 is appropriate since the schema already documents the parameter fully.

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

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

The description clearly states a specific verb (resolve) and resource (money-path/trade path) for an instrument/asset concept, and specifies the output: venues, execution pipeline, and place_order route. This distinguishes it from sibling tools like get_market or get_orderbook, which focus on market data rather than the full execution path.

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 it ('given an instrument/asset concept, return...') but does not explicitly contrast with alternatives or state when not to use it. There is no mention of sibling tools like search_markets or get_market, leaving the agent to infer the appropriate context. It provides context but lacks exclusions or alternative routing.

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

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

Annotations already declare read-only, idempotent, non-destructive, and closed-world, but the description adds real context beyond them: data is collected every 6 hours and audited before publishing, null means unknown, every number carries {value, unit} and as_of, and it explicitly frames itself as 'a research screen, not a signal.' These freshness, null-semantics, and disclaimer disclosures are genuinely useful and not derivable from the annotations.

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

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

The description is a ~250-word run-on dominated by parenthetical field enumerations, with the actual task statement buried in the first clause and no paragraphing or bullet structure. Almost none of it is front-loaded and much of the field listing repeats information the payload itself would carry.

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 output schema, the description carries the burden of explaining returns, and it does enumerate the payoff fields, their shapes, and sources/freshness extensively. For an agent deciding whether to call it, nothing essential is missing, though the sheer volume makes it hard to extract the key facts.

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 100% and documents the single symbol parameter, so baseline is 3, but the description adds meaning the schema does not: case-insensitivity and the tie-break rule that a shared ticker resolves to the largest market cap. That said, most of the description is about the return payload rather than the input.

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 concrete verb+resource ('One coin in full by slug ... or ticker') and implicitly scopes it as the per-coin detail view distinct from sibling list tools like gem_screener_ranked and gem_screener_picks. An agent can tell what it returns, though the framing question ('is this token a gem or a casino?') and the avalanche of field names obscure the core statement. It is clear but not cleanly differentiated from every sibling.

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

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

It explains lookup mechanics (slug or ticker, case-insensitive, shared ticker goes to largest market cap) and alludes to the picks gate, but never states when to reach for this tool versus gem_screener_ranked or gem_screener_picks. Usage is implied rather than directed.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the bar is lower. The description still adds real behavioral value: a 150-word cap, 'unknown' as the fallback for missing facts, linked sources, an appended disclaimer, a 6-hour collection cadence with pre-publish auditing, and the structural guarantees that numbers are {value, unit} and every record carries as_of.

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 is front-loaded in the first clause, and the long middle enumeration of report sections earns its place because there is no output schema. The slash-separated run-on writing is dense and harder to parse than it needs to be, which keeps it out of the top score.

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 output schema, the description usefully characterizes the return: section list, word limit, unknown-handling, unit shape, and as_of field. Provenance and freshness are also covered. Minor gaps remain around error behavior for an unrecognized symbol and how slugs resolve against tickers.

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 100% and the single parameter already documents that 'symbol' accepts a slug or ticker with examples. The description adds nothing beyond 'one coin', so the baseline of 3 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 specific verb and resource ('Find crypto gems: the short Degen report on one coin') and enumerates the report's sections, so an agent knows it returns a single-coin narrative rather than a ranked list. However, it never names its obvious siblings (gem_screener_coin, gem_screener_picks, gem_screener_ranked), so differentiation is left 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?

'A research screen, not a signal' and 'Read-only, no key' give some framing for how to treat and call it, and 'on one coin' implies single-symbol scope. But there is no explicit when-to-use vs when-not guidance and no routing to the sibling gem_screener tools for list or ranked views.

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

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

Annotations already declare readOnly/openWorld=false/idempotent/non-destructive, and the description adds genuinely new behavioral context: data is collected every 6 hours and audited before publishing, every number is {value, unit}, every record carries as_of, and no API key is needed. It does not contradict any annotation.

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 purpose and packed with useful detail in a few sentences. Slightly dense with parentheticals (sort list, dataset provenance), but no sentence is 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?

No output schema exists, so the description must carry return-shape burden, and it partly does: it discloses that records carry {value, unit} numbers and an as_of field, plus the paging mechanism. It stops short of full field enumeration, which keeps it from a 5.

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 100%, so baseline is 3, but the description adds real meaning beyond the schema: it spells out the full sort enum including the non-obvious 'price_vs_revenue (cheapest first)', restates the 1-100/default-20 limit, and clarifies that offset pages should follow `next`.

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+scope: the full ranked list of ~215 tokenized crypto apps or chains, paged. It is clearly distinguishable from siblings like gem_screener_coin (single coin) and gem_screener_picks, and names the exact source (EventTrader's Gem Screener).

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 what the tool returns (full ranked list vs. single-coin sibling), the sort modes available, and the paging contract via `next`. It also frames intent with 'A research screen, not a signal.' However, it never explicitly names an alternative tool or states when NOT to use this one.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds meaningful context beyond that by flagging that the record is self-attested, not third-party audited, and that only git stats are independently inspectable—an important trust caveat for how the returned data should be interpreted.

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 dense but not bloated; every clause contributes either content or an important caveat. The parenthetical caveat interrupts the flow slightly, but the overall structure effectively front-loads the core resource and then lists its contents.

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 tool with no output schema, the description explains the nature of the record and enumerates its main fields, which is sufficient for a first call. It could be slightly richer on what 'verification endpoints' means or how the record is obtained, but nothing critical is missing.

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

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

The tool has zero parameters, so the description cannot add parameter-level meaning. The schema coverage is trivially 100%, and the description rightly focuses on what the returned record contains rather than 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 an 'AI-native provenance record' and names its concrete contents: live git stats, AI authorship percentage, founder credentials, patents, and verification endpoints. This is specific enough to distinguish it from the many other getter tools, none of which target provenance proof.

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

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

There is no explicit guidance about when to call this tool versus alternatives, nor any mention of when not to use it. The purpose implies usage, but the description never states a use case or points to a sibling tool, so an agent gets no 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?

Annotations already cover readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds valuable context by flagging 'tradeability caveats' for the models, alerting the agent that some models may have limitations. This goes beyond the annotations and does not contradict them.

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