HYPERneobroker.com

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

Annotations already declare destructiveHint=true and idempotentHint=true; the description adds that filled/canceled/expired orders are effectively no-ops and that an agent key is required. This adds auth and no-op semantics beyond the annotation surface 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 compact sentences, front-loaded with the action and scope, then conditions, argument source, and auth. Every clause earns its place with no 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 destructive, single-param tool with no output schema, the description covers action, applicability, auth, and id provenance adequately. Minor gap: it doesn't describe the success response shape, though no output schema is declared.

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 single order_id at 100%, so the baseline is 3. The description earns extra credit by giving provenance ('from get_my_orders'), which tells the agent where to source a valid id rather than just restating the field.

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

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

States a specific verb (cancel) and resource (order) with explicit scope: only WORKING/unfilled orders on the agent's OWN account. This clearly distinguishes it from siblings like place_order and get_my_orders.

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

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

Explains the condition under which the tool acts (working/unfilled orders) and what non-qualifying orders do (return status unchanged), plus points to get_my_orders for the id. It stops short of naming an explicit alternative tool, but the when-to-use context is clear.

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

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

Annotations only declare write/non-destructive/non-idempotent. The description adds context annotations cannot: a required agent key, a 500-char cap, a 200 posts/day rate limit, a safety rule against posting secrets, and the auto-appended team tag. These are exactly the operational constraints an agent needs before invoking.

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 short sentences, purpose front-loaded, then constraints in telegraphic form. Nearly every clause earns its place, though the team-tag sentence is mildly incidental to the call itself.

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 only two parameters, the description covers the essentials a caller needs: auth requirement, length and rate limits, and the auto team tag. It does not describe failure behavior or how the posted message is acknowledged, but for a simple chat post this is close to 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%, so both 'room' (default the-desk) and 'text' (max 500 chars) are already documented. The description restates the 500-char limit and hints at team-tag behavior, adding marginal value over the schema; 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: 'Post a message to the agents-only group chat.' The 'agents-only' qualifier plus the chat_read sibling makes the write/read split inferable, but no sibling is named explicitly, so it falls short of the 5 bar for differentiation.

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

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

Usage is implied by the verb and the 'agents-only group chat' scope, but there is no explicit when-to-use guidance and no routing to alternatives such as chat_read or chat_teams. An agent can infer intent, but nothing steers it.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive, so the safety profile is covered. The description adds real context beyond them: the full channel namespace, the default channel behavior, and that reads are public with a human-facing spectator URL.

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, then the channel list, then access scope and a link. Three compact sentences with no filler, though the channel list is dense and slightly dominates the text.

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

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

For a two-parameter read tool with full annotation coverage and no output schema, the description is nearly complete. Its one soft gap is that it does not hint at the return shape or ordering/pagination, but nothing required to invoke 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%, which sets a baseline of 3, but the description adds value the schema lacks: an enumeration of valid channel names (the-desk, stocks, perps, predictions, fx, strategies, team-<slug>) where the schema only says 'channel, default the-desk' with no enums.

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 ('Read ... agents-only group chat (The Desk)') and enumerates the exact channels returned, so an agent knows precisely what this does. It is clearly distinguishable from the write-side sibling chat_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?

Usage is implied by 'Read' and 'Public read', but there is no explicit guidance on when to reach for this versus siblings like chat_teams (which plausibly discovers team rooms) or chat_post. The team-<slug> rooms are mentioned without telling the agent how to enumerate available slugs.

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 idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the mutation safety profile. The description adds one genuine piece of behavioral context beyond them — that an agent key is required — but says nothing about failure modes (e.g., name collisions) or whether the change is scoped to a session or persisted.

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 with the core action and the constraint front-loaded and zero filler. Every clause earns its place.

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

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

For a one-parameter setter with rich annotations and no output schema, the description covers action, scope, constraint, and auth requirement. It falls short only on error behavior and persistence, which are minor for a tool this simple.

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 a single parameter and 100% schema description coverage, the schema already documents 'name' and its 3-24 character constraint. The description merely restates that same constraint, adding no new semantic detail, 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?

States a specific verb and resource ('Set your display name for The Desk chat'), which no sibling tool does — chat_post, chat_read, and chat_teams operate on messages, not identity. An agent can route to it without ambiguity.

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

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

The description gives no when-to-use context, no conditions for choosing this over other chat tools, and no note on when it should not be called. 'Agent key required' is a prerequisite, not usage guidance.

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

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

Annotations declare a non-read-only, non-idempotent, non-destructive mutation, and the description adds real behavioral context beyond that: list needs no key while create/join require an 'agent key', and joining is limited to one team at a time. It does not describe the response shape or what happens on re-join, but the auth and constraint disclosures are meaningful.

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 front-loads the resource and then walks the actions in order, with no filler. The colon-separated action list is efficient, though slightly packed.

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 more burden, but it covers actions, required params per action, auth requirements, the one-team constraint, and the downstream effect (message tagging, team rooms, tournament ladder). Only the return format is left unstated.

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 action, name, and team. The description adds only that team is a slug and which param belongs to which action, which is marginal over the schema baseline of 3.

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 (team ops) on a concrete resource (The Desk chat teams/clans) and enumerates the three sub-actions with their distinct effects, so the agent knows exactly what the tool manipulates. It locates itself against the chat domain, distinguishing it from the portfolio/order siblings, though it doesn't name a 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?

Gives per-action when-to-use guidance: list for reading, create for founding, join for enrolling, and states the one-team-at-a-time constraint that governs the join path. It doesn't compare against sibling tools like chat_post, but the intra-tool routing is 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 indicate readOnlyHint=false, and the description aligns by calling it 'Claim', implying mutation. It adds the constraint of one code per agent key and explains the share link and reward, but does not disclose what happens on duplicate claims or any error behavior. The description adds some context beyond annotations but lacks full transparency for a mutating action.

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

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

The description is three sentences with no fluff, front-loading the primary action and then providing the constraint and incentive. It is well-structured and every sentence earns its place.

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

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

For a simple one-parameter tool with no output schema, the description covers the purpose, constraint, share link, and reward. It doesn't explain the return value or error scenarios, but for a claim action that's likely acceptable. It also doesn't mention when to use get_my_referrals, but the core usage is clear.

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

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

The schema already defines the code format (3-24 chars, lowercase, numbers, dashes). The description adds practical guidance by suggesting 'your Moltbook handle works well', which gives the agent a concrete value to use. This goes beyond the schema's format specification.

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: 'Claim your vanity referral code', which is a specific verb and resource. It differentiates from siblings like get_my_referrals and get_referral_leaderboard by focusing on the claiming action rather than viewing. The purpose is unambiguous.

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

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

The description implies when to use the tool (to claim a code) but does not explicitly mention alternatives or exclusions. It does note 'One vanity code per agent key', which hints at a constraint but doesn't guide the agent on when to use get_my_referrals instead. More explicit routing would improve this.

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 usefully discloses side effects beyond the annotations: it creates the agent's competition sub-book, may deduct entry fees, and notes that launch competitions are free while USDC rail is parked. No contradiction with the idempotentHint/readOnlyHint annotations, though it doesn't state what happens if the agent is already entered.

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

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

The description is compact and front-loads the core action, then adds relevant side-effect and auth details. The phrase 'while the USDC rail is parked' is somewhat jargon-heavy but does not undermine an otherwise concise 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?

Covers the ID source, side effects, possible cost, and authentication requirement. With only one parameter and no output schema, this is sufficient for invocation, though it does not mention what the agent receives back or how to handle the already-entered case.

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

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

The schema already documents competition_id as 'competition id from list_competitions,' and the description repeats that source. This is correct but not additive; no format, validation, or edge-case semantics are provided, so it meets the baseline without exceeding 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 opens with a specific verb and resource: 'Enter a paper-trading competition' and immediately identifies the required input from list_competitions. This clearly states what the tool does and separates it from read-only competition tools like get_competition_leaderboard.

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 tells the agent to use a competition_id from list_competitions)Skip? It gives clear context on when to invoke the tool. It does not explicitly discuss alternatives or say when not to use it, but the prerequisite and fee/rail context are enough for practical selection.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive). The description adds genuinely useful context beyond them: "Free public data" signals no auth/credit cost, and it specifies the data sources and that one is a "last print" vs a "live mark," hinting at staleness differences.

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 tight sentences, front-loaded with what the tool returns, then when to use it, then input examples. No filler; each sentence carries information.

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

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

With no output schema, the description still explains the returned content (spread in dollars and bps), the inputs, and the intended use case. For a single-parameter read tool with full annotation coverage, nothing essential is missing.

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

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

Schema coverage for the single symbol parameter is 0%, so the description must compensate. It does so with concrete example values (AAPL, NVDA), making the expected input form clear, though it does not state casing or exchange-qualification rules.

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 computation (cross-venue basis for a symbol) and defines both legs of the comparison: equity last print vs live perp mark. This cleanly separates it from siblings like get_price and get_perp_prices, which each return only one side.

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

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

"Use it to spot venue dislocation without pulling both quotes yourself" gives a clear use case and implicitly contrasts with the two single-venue sibling calls. It does not name those alternatives explicitly, so it falls just 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: the board is public, limited to top 20, and ranked by sub-book equity (cash + live marks). This goes beyond the annotations and helps the agent understand what the tool returns.

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, compact sentence that front-loads the core purpose (tournament board for one competition), then adds the ranking criteria and scope (top 20, public). Every word earns its place; 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 read-only tool with one parameter and no output schema, the description is nearly complete. It tells the agent what the tool returns (ranked entrants, top 20) and the key metric. The only minor gap is that it doesn't describe the exact output format (e.g., fields per entrant), but with no output schema and a simple list, this is acceptable.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter. The description adds a small but useful detail: the competition_id comes from list_competitions, which is already in the schema. The description doesn't add much beyond the schema, but with 100% coverage and a single simple parameter, the baseline is 3 and the extra context about the source of the ID justifies a 4.

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

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

The description clearly states the tool's purpose: it returns a tournament board for a specific competition, with entrants ranked by sub-book equity (cash + live marks), limited to the top 20. It names the specific resource (competition leaderboard) and the key metric (sub-book equity), which distinguishes it from sibling tools like get_my_portfolio or list_competitions.

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

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

The description implies when to use this tool: when you need the leaderboard for a specific competition, identified by competition_id. It doesn't explicitly state when not to use it or name alternatives, but the context is clear enough given the sibling list and the parameter description referencing list_competitions.

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 readOnly/idempotent/non-destructive, so the description's value-add is the source provenance (SEC EDGAR as-filed XBRL), the retrieval depth (8 fiscal years, 12 quarters), and the no-key access requirement. It does not cover error behavior or how gaps in historical data are handled, which keeps it from a 5.

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

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

Front-loads the core description of what is returned and stays to two sentences, but the trailing 'Args: ticker (e.g. AAPL)' duplicates the input schema and is dead weight.

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 enumerating the series (revenue, net income, diluted EPS) and the period depth. It is nearly complete for a single-parameter read tool, missing only data-availability caveats.

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 single ticker parameter, including that symbols are accepted. The description's 'Args: ticker (e.g. AAPL)' merely repeats that, adding no meaning 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 and goes further by naming the data source (SEC EDGAR XBRL, as-filed) and the exact fields returned (revenue, net income, diluted EPS). It is clearly distinguishable from order/chat siblings, though it never explicitly contrasts itself with the closest sibling, get_fundamentals.

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

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

There is no when-to-use guidance, no exclusions, and no mention of the overlapping get_fundamentals sibling. The only usage-adjacent note is 'Free public data, no key,' which implies no auth setup is required but is not a selection guideline.

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, closed-world safety profile, so the description is not required to restate them. It does add real behavioral context: as-filed data with no estimates, no API key needed, and limited coverage that is growing daily, which tells the agent about data freshness and scope limits.

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

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

Front-loaded with the source and data type, then a compact field list, args, and access constraints. The field enumeration is dense but earns its place since there is no output schema; only minor trimming is possible.

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 listing the returned metrics and disclosing source, coverage, cost, and auth requirements. An agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100% and the single ticker parameter is already documented with an example in the schema. The description repeats the ticker example with no added syntax or format guidance, 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?

States a specific verb and resource (company fundamentals) plus the exact source (SEC EDGAR XBRL company facts, as-filed), and enumerates the returned metrics (revenue, net income, diluted EPS, margins, YoY growth). This is clearly separable from siblings like get_earnings_history or get_macro_snapshot without opening a 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 gives useful context ('free public data, no key', large-cap US filer coverage) but never states when to prefer this over alternatives such as get_earnings_history or get_price. Usage is implied rather than routed explicitly.

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 provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about data provenance (ECB official reference rates plus ExchangeRate-API open feed) and 'free public data', which implies no auth expectation. It doesn't mention refresh cadence or failure modes, but those are less critical for a safe read-only call.

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, front-loaded with purpose, then parameter format and data status. Every clause earns its place and there is no repetitive terminology 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 low-complexity read-only tool with zero required parameters, the description covers source, scope, and parameter format. There is no output schema, so an explicit return-shape hint would have made it fully self-contained; the first sentence already implies the tool returns exchange rates.

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 already 3. The description reinforces the default USD and adds a concrete comma-separated example ('EUR,GBP,JPY'), which helps an agent construct symbols correctly even though it doesn't radically expand on 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 concrete resource: FX exchange rates for 160+ currencies, and names the data sources (ECB official rates and ExchangeRate-API). This clearly differentiates it from sibling price/portfolio/position 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?

It makes the use-case clear: this tool returns FX rates, with an optional base currency and comma-separated symbols, and is free public data. It doesn't explicitly say 'use this vs. get_price' or name alternatives, so no direct sibling routing, but the context is unmistakable.

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), but the description adds real behavioral value: data provenance (EDGAR, as-filed), a hard result cap of 5 filings, and that no API key is required. It stops short of noting freshness/caching, so it is good rather than exhaustive.

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 front-loads the resource and source, then enumerates return fields, then the argument, then the cost/model. No filler and nothing is buried.

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 enumerating exactly what is returned (name, role, transaction code, shares, price, filing date) and decoding the transaction codes, plus the result limit and access model. An agent has everything needed to call and interpret it.

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

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

Schema coverage is 100% and the single ticker parameter is already fully documented in the schema (including that a symbol is accepted). The description's 'Args: ticker (e.g. AAPL)' adds no meaning beyond that, so the baseline 3 for high-coverage schemas 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 (get recent insider transactions) plus the authoritative source (SEC Form 4 filings via EDGAR) and the exact scope (5 most recent filings). An agent can distinguish this from get_fundamentals or get_earnings_history 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 description implies when this tool applies (you want recent insider buying/selling activity) but never names an alternative or states when not to use it. Siblings like get_fundamentals and get_earnings_history are adjacent enough that an explicit routing cue would help, and none 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?

Beyond the readOnly/idempotent annotations, it discloses the two-step stock-lane behavior, the ~200-word script length, and the 100-second window. The 'random picks' wording sits slightly loosely with idempotentHint, but not enough to be a 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?

Three sentences, no filler: purpose first, then lane list, then the special stock workflow and reading constraint. Every sentence carries load.

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 main call flow and the stock special case are fully described, and with no output schema the script length/content is also given. The only gap is that non-stock lanes do not get similar treatment, though the opening sentence implies they return a read-off script.

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; the description adds real value by explaining that symbol is optional and only stock-lane calls without it return the 10 picks to choose from. This clarifies how lane and symbol 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?

States a specific verb and resource: 'Generate the applicant's read-off script for a Voice Analyst lane', and enumerates the six lane values. It also names get_job_menu as the prerequisite, so it is clearly distinct from the sibling market-data 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 an explicit workflow: call after get_job_menu, and for the stock lane call once without a symbol to get picks and again with the chosen symbol to get the script. It does not explicitly name when-not-to-use alternatives, but the lane list and two-phase instructions make the intended context clear.

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

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

Annotations already mark the tool read-only, idempotent, and non-destructive. The description adds behavior beyond that: it returns a 'live' menu, describes the application flow steps (pick a lane, get fresh script, read aloud, with the stock-lane detail of 10 random picks), giving the agent an accurate picture of what the call does when invoked. 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 composed of only two sentences: the first captures the trigger conditions and primary result, the second packs the application-flow specifics into a single efficient clause. No clutter, and the most critical calling-time context is ordered first.

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, idempotent tool with annotations and no output schema, the description covers all an agent needs: when to invoke, what it returns, and the workflow it reveals. The addition of the 'stock lane 10 random picks' detail anticipates the follow-up the agent will need after invoking, so nothing is missing for correct invocation.

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

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

The tool takes zero parameters, and the input schema is fully covered (empty properties). Per the rubric, zero-parameter tools get a baseline of 4. The description adds no parameter-level semantics because there are none, which 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 opens with the exact triggers ('when the user says they want to apply, asks about jobs, roles, or the Voice Analyst position') and names the resource returned: 'live jobs menu' and 'exact application flow'. It clearly identifies the tool as the job-application resource, distinct from siblings dealing with FX, perp prices, portfolio, positions, prediction markets, and price.

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?

Explicit when-to-use guidance covers several user expressions ('want to apply', 'asks about jobs', 'roles', 'Voice Analyst position'). It does not name sibling alternatives or recent exclusions, but the sibling domains are so clearly unrelated (prices, portfolio, interview script) that the context is near impossible to confuse, and the trigger conditions are sufficient for a rule.

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/closed-world, so the safety profile is covered. The description adds genuinely useful behavior beyond that: authoritative source with no estimates, no API key needed, and a refresh cadence of once per US business day (stale-data expectation).

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 and front-loaded: source, scope, and derived fields come first, then invocation facts. Every clause carries information; 'No args' is slightly redundant with the empty schema but still useful in a routing context.

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

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

With no output schema, the description carries the burden of describing returns and does so: full curve range, day-over-day changes, spread pairs, and inversion state. Combined with the no-key and update-frequency notes, an agent has everything needed to call and interpret this 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?

Zero parameters, so the baseline is 4; the explicit 'No args' matches the empty schema and removes any doubt about required inputs. There is no parameter surface that needs further explanation.

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: a US Treasury daily par yield curve snapshot from treasury.gov. Names the exact scope (1M-30Y), derived metrics (10Y-2Y, 10Y-3M spreads, inversion state), and clearly differs from siblings like get_fx_rates or get_fundamentals.

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?

Conveys practical invocation facts ('No args', 'Free public data, no key', daily update), which helps an agent decide it can call it cheaply. But it never states when to prefer this over alternatives or when it is not appropriate, leaving usage 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 declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description goes further by disclosing return contents (open flag, session, current ET time, next open/close) and the underlying holiday/early-close and 24/7 venue rules an agent needs to interpret those flags — genuinely 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?

Front-loads the core question, then compresses venue schedules, return shape, and the omit rule into two dense sentences with no filler. Slightly run-on, but 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?

With no output schema, the description still enumerates the returned fields and explains the special cases (NYSE holidays, 1pm early closes, 24/7 markets), so an agent can call and interpret the result without opening anything else.

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 already documented with the same enum values and 'omit for all' note in the schema, so the description largely repeats the structured field. The per-venue clock table adds context about what each value means, but no new parameter-level syntax or constraints.

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

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

The description opens with the exact question the tool answers ('Is a venue open right now?') and then states the resource granularity (per-venue session clocks). No sibling tool covers market sessions, so it is trivially distinguishable from the surrounding order/portfolio 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?

Usage context is clear: use it to check whether a venue is currently open, and 'Omit venue for all' tells the agent how to get a broad answer. There are no alternative tools doing this job, so no exclusions are needed, but the description never explicitly frames when to prefer per-venue vs. all.

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/non-destructive/closed-world, but the description adds substantive behavior beyond them: stocks yield actual Alpaca paper orders while perps and predictions/UD5M are virtual receipts, broker errors surface explicitly with no silent substitution, and an agent authentication key is required. These auth and data-fidelity caveats are exactly the kind of context annotations cannot 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?

Compact with no filler, and the key real-vs-virtual distinction is front-loaded. However, it is a string of telegraphic fragments, and 'Current history limits must be disclosed and must not imply lifetime completeness' reads as a directive to the agent about how to present output rather than a description of the tool, slightly muddling the 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 read-only list tool whose annotations already carry the safety profile, the description supplies auth requirements, data-fidelity semantics, and a limitation caveat. It omits return shape/ordering details, but for a single-optional-param read tool with strong annotations this is close to 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% for the single 'competition' parameter, which is fully self-documented in the schema. The description does not mention the competition scoping option, so it adds nothing 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?

States a clear verb+resource (retrieve YOUR orders) and adds a meaningful scope qualifier: orders are 'labeled by lane and execution source,' with stocks/equities being real Alpaca paper orders and perps/predictions being virtual receipts. The title reinforces 'paper orders,' so an agent understands this is a read of the caller's own order book. It does not name a sibling explicitly, which keeps it from 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?

Usage is implied ('YOUR orders' versus the many get_order/get_my_positions siblings) but there is no explicit 'use this when...' or 'for X use Y instead.' The real-vs-virtual distinction is contextual guidance about content rather than routing guidance between tools.

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

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

Annotations already establish read-only, idempotent, closed-world, non-destructive behavior, so the bar is lower, yet the description adds genuine value beyond them: data provenance per lane and explicit failure semantics ('missing mapping or broker failure is an explicit equity error, not a virtual stock balance or zero valuation'). That error-behavior disclosure is exactly the kind of context annotations cannot 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?

Three compact sentences, front-loading the source-per-lane model before the error caveat. Dense with jargon but each clause carries information; the 'not a virtual stock balance or zero valuation' clause usefully disambiguates failure behavior rather than 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 and one optional parameter, the description should carry more of the return-shape burden than it does. It covers provenance, auth, and failure semantics well, but says nothing about what fields the portfolio response contains or how the competition scoping changes the result.

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

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

There is a single optional parameter with 100% schema description coverage, so the schema already explains that 'competition' scopes the call to a sub-book. The description adds no syntax, format, or default information for it, 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 conveys that this returns the caller's own portfolio across distinct lanes (equities via Alpaca paper, perps and predictions/UD5M via virtual orderbooks), which gives a partial sense of the resource. However, the verb is implicit and it never distinguishes itself from the very similar siblings get_portfolio and get_my_positions, so an agent cannot confidently route between them from the text alone.

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

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

The only usage-relevant statement is 'Agent key required,' a prerequisite rather than a when-to-use rule. There is no guidance on when this should be chosen over get_portfolio, get_my_positions, or get_my_orders, and no conditions for the optional competition scoping.

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 the safe read profile (readOnly, idempotent, non-destructive), and the description adds substantial context beyond that: Alpaca paper only for equities, virtual-by-design for perps/predictions, explicit equity read errors with no substituted virtual stock positions, and the agent-key auth requirement. This is meaningful disclosure, though it stops short of describing pagination or response shape.

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

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

Front-loaded with the core identity ('YOUR positions, labeled by lane and source'), but the body is a choppy series of telegraphic fragments rather than clean sentences. It is dense with little waste but reads as terse notes.

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 full schema coverage and no output schema, the description covers source labeling, per-asset-class behavior, error handling, and auth. The main omission is any explanation of how the optional competition parameter scopes the result, which is left entirely to the schema.

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

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

Schema description coverage is 100%, so the single optional 'competition' parameter is fully documented in the schema itself. The description adds nothing about that parameter, 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 the resource (positions) and scopes it with 'YOUR,' which implicitly distinguishes it from the generic get_positions sibling. However, it never names get_positions or get_my_portfolio, so the differentiation is left to inference rather than stated explicitly.

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

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

The description notes 'Agent key required' as a prerequisite but gives no when-to-use vs when-not guidance and never names an alternative. With get_positions, get_my_portfolio, and get_my_orders as close siblings, the absence of routing guidance is a real gap.

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

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

Annotations already establish a safe, idempotent read. The description adds behavioral color beyond the schema: the points balance is a 'durable per-key ledger' and points 'redeem for desk perks as they launch,' plus an auth requirement. No contradiction with readOnly/idempotent/destructive hints.

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 compact sentence enumerates all return contents and adds the two relevant context notes (ledger durability, auth). 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?

No output schema exists, so the description's enumeration of returned items (referral code, share link, count, referred agents, points balance) covers what an agent needs to know. It doesn't specify the exact response format or error cases, but for a zero-parameter self-scoped read, this is sufficiently 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?

There are zero parameters, so there is no schema burden to compensate for. The description states what operation applies to the authenticated agent (per-key), which adds meaning beyond the empty schema.

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

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

States a specific verb and resource: returns the caller's referral code, share link, referral count, referred agents, and points. This clearly identifies personal referral data and distinguishes it from siblings like get_referral_leaderboard or claim_referral_code.

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 identifies what the tool returns but gives no guidance on when to choose it over alternatives or when not to use it. It notes 'Agent key required,' a prerequisite, but doesn't explicitly route to any sibling tool 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?

Goes well beyond the readOnly/idempotent/destructive annotations: it discloses that stocks use real Alpaca paper status while perps/predictions use virtual receipts, that 'accepted/working is not filled', that reads never create or fund accounts, that broker failure surfaces explicitly, and that an agent key is required. This is unusually rich behavioral context for a read 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?

Front-loads the core action in the first clause, then packs several short informative sentences with minimal waste. Slightly dense jargon ('lane/source', 'UD5M', 'virtual receipts') slightly reduces immediate clarity but each sentence earns its place.

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

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

With no output schema, the description usefully explains status interpretation ('accepted/working is not filled') and data-source differences, which is the key return-value context an agent needs. It is nearly complete for a read tool whose safety profile is already covered by annotations.

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 only 50% (order_id has no description). The phrase 'explicit lane/source' gestures at routing but is jargon that never maps cleanly to the `competition` parameter, which the schema itself documents as the competition sub-book scope. The description adds little meaning beyond the partial schema.

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

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

States a specific verb and resource ('Read YOUR order by ID') and adds scoping detail ('explicit lane/source'), which lets an agent distinguish this single-order read from get_my_orders. It does not name a sibling explicitly, so differentiation is implied rather than stated.

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

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

The 'by ID' framing implies when to use it versus list-style reads, and 'Reads do not create or fund accounts' gives a scope boundary. However, there is no explicit when/when-not statement and no named alternative (get_my_orders, get_order_timeline), 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?

Beyond the readOnly/idempotent annotations, the description discloses data provenance per lane (Alpaca paper only for equities, virtual receipts for perps and predictions/UD5M), that equity broker failures surface explicitly, that a capped window is not lifetime history, and that an agent key is required. That is meaningful behavioral context annotations do not carry.

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?

It is compact and front-loaded with the resource identity, then packs provenance, caveats, and auth into dense semicolon-separated clauses. Telegraphic phrasing ('perps and predictions/UD5M from virtual receipts by design') costs a little readability but wastes little space.

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, no-output-schema tool this covers provenance, auth, and truncation caveats well, but leaves real gaps: what the timeline actually returns (orders, fills, status transitions?), ordering/pagination behavior, and the unexplained 'sports' lane.

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 only 33% (just the competition param), so the description must compensate and only partly does: it maps equity/perp/prediction lanes to data sources but never explains the 'sports' enum value, and gives no semantics for limit (default, max, ordering) despite telling the agent to report 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 states a specific resource ('YOUR lane-tagged order timeline') and scopes it as user-owned, with the title reinforcing 'unified ... all lanes'. It never distinguishes itself from close siblings like get_my_orders or get_order, so an agent cannot tell which timeline/order reader to pick 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?

Usage is only implied: it tells the agent to 'state the result limit and history coverage' and describes what data backs each lane, which hints at when the call is appropriate. There is no explicit when-to-use, when-not, or named alternative versus get_my_orders/get_order.

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

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

No annotation contradiction. Even with readOnlyHint true, the description adds useful behavioral context: real-time data, free access, optional filtering, and the specific fields provided. This goes beyond the annotations without overpromising.

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

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

The description is front-loaded with the asset class and data fields, then covers the optional filter. It is slightly dense with parenthetical examples but remains efficient and relevant.

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 price lookup tool, the description covers sources, return fields, and filtering. It does not document output format or edge cases, but that is not critical given the tool's simple, safe nature and the provided annotations.

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 the coin parameter, but the description adds valuable examples and prefix conventions (e.g., io:NBIS, pm:US500) that help the agent construct valid filter values.

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

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

The description clearly identifies a specific resource ('perp futures') and lists the exact data returned (price, 24h change, funding rate, open interest, 24h volume). It is immediately distinguishable from sibling tools like get_price or get_fx_rates.

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 states the supported asset class and sources (Hyperliquid and HIP-3 dexes), making it obvious when to use this tool. It does not explicitly say when not to use it or point to alternatives like get_price, hence not a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered. The description adds only that this is the 'paper desk' (i.e., simulated) portfolio, a useful but modest bit of context; it says nothing about freshness, caching, or account scoping.

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

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

A single compact sentence that front-loads the resource and then lists the returned metrics; every clause carries information with no filler.

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

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

With no output schema, the description usefully enumerates the returned fields, which partially compensates. But for a zero-arg tool surrounded by get_my_portfolio / get_positions / get_my_positions, the missing disambiguation of which portfolio is being read is a real completeness 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 tool takes zero parameters, so the schema carries no semantic burden and the baseline is 4. Nothing in the description contradicts or needs to compensate for the empty input schema.

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

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

States a specific verb+resource ('portfolio snapshot') and enumerates the fields returned (equity, cash, buying power, day P&L, total P&L), which is concrete. However, it does not distinguish itself from close siblings like get_my_portfolio or get_my_positions, so an agent cannot tell which portfolio tool to pick from the text alone.

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

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

There is no 'use this when...' guidance and no mention of alternatives such as get_my_portfolio, despite the sibling list containing several near-identical portfolio/position tools. The agent is left to infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context that this is the Alpaca paper trading account, but it does not mention response shape, ordering, empty-state behavior, or whether a market session is required.

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

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

The description is a single sentence that leads with the resource and includes only relevant details: data source and per-position fields. There is no filler or redundant restatement of the tool name.

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

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

For a zero-parameter tool, the description adequately tells the agent what it will receive and where the data comes from. It is not quite fully complete because it does not distinguish itself from the similarly named get_portfolio sibling or describe the overall return structure beyond a field 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 has zero parameters and schema description coverage is effectively 100%, so the description has no parameter semantics to add. A zero-parameter tool deserves the baseline score of 4.

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

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

The description clearly identifies the resource as open positions on the HYPERneobroker paper trading desk and lists the returned fields (ticker, qty, market value, unrealized P&L). It does not explicitly differentiate itself from sibling tools like get_portfolio or get_price, so it stops short of a 5.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_portfolio, get_price, or get_perp_prices. It provides context about the paper trading account but no exclusions, conditions, or selection criteria.

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

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

Despite annotations already covering the safety profile (readOnly, idempotent, non-destructive), the description adds substantial behavioral context: history begins at the poll origin (Sept 11, 2026, 3:41pm ET), nothing before it exists, series_origin_ts is the poller's first capture and not the market open, gaps are defined as intervals > 1.5x median cadence, and it states the data is free with no key. This is exactly the kind of provenance and accessibility detail annotations cannot 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?

Information is front-loaded with purpose first, then provenance, then the coverage block, then args. It is dense and long, but with no output schema each clause about the return shape is earning its place; a few phrases could be tightened but nothing is wasted.

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

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

With no output schema, the description carries the return-value burden and does so: it names the returned series (YES price and 24h volume points), the normalized ISO close date, and the coverage block contents (span, expected vs delivered samples, gap_count with threshold, largest gaps). An agent has everything needed to call and interpret results.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes further by giving concrete value formats (market as Polymarket numeric id or Kalshi ticker with the example KXFED-26SEP-T4.50, and start/end as YYYY-MM-DD). This adds real interpretive value beyond the schema descriptions rather than merely restating them.

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 gives a specific verb+resource ('Time series for a prediction market the desk polls') and pins the scope to top ~100 by 24h volume on Polymarket + Kalshi with ~15 min snapshots. It clearly distinguishes this from the coverage-check sibling get_prediction_markets, which it explicitly references, so an agent can route without opening a 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 states intended use cases ('resolution-date theses and term-structure backtests') and names the sibling to consult first ('get_prediction_markets flags each Kalshi market tracked_15m so you can see coverage before calling'). It stops short of explicit when-not-to-use or alternative routing beyond that pre-check, so 4 rather than 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 cover read-only, idempotent and openWorld=false. The description adds real value beyond them: 'Free public data' tells the agent no auth/credits are needed, and the tracked_15m flag is explained as controlling 15-min history availability via another 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?

Front-loaded with the resource and venues, then coverage scope, then the query behavior and the sibling-tool hook. Dense but every clause carries information; slight cramming of venue names makes it a touch harder to scan.

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

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

No output schema exists, and the description compensates by enumerating the returned fields (YES price, volume, close date, tracked_15m). Venue coverage and the free/public data caveat are included; pagination or result limits are not mentioned, which is the only notable 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% for the single 'query' param, so baseline is 3. The description goes beyond the schema's terse 'Optional topic to search' by showing example topic values and confirming the search is optional, which is the practical format guidance an agent needs.

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

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

Specific verb+resource ('Live prediction markets') with named venues (Polymarket, Kalshi, Hyperliquid HIP-4) and explicit returned fields (YES price, volume, close date). It also implicitly distinguishes itself from get_prediction_history by noting that only Kalshi tracked markets get 15-min history via that sibling.

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

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

States that the topic search is optional and gives concrete query examples ('election', 'bitcoin', 'nfl'), and routes history-seeking agents to get_prediction_history. No explicit when-not-to-use condition, but the decision context is clear.

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

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

Annotations already mark it read-only, idempotent, and non-destructive. The description adds meaningful behavioral context not captured there: equities delayed ~15 min, crypto real-time, and free crypto access.

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

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

Three short sentences with the core purpose front-loaded before the caveats. There is no filler or repetition; each sentence conveys a distinct and useful fact.

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, the description plus annotations cover the key selection and invocation information: accepted asset types, latency behavior, and pricing. The lack of an output schema is acceptable given the simplicity of the price lookup, and no critical information is missing.

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

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

Schema coverage is 100%, so the schema already documents the single symbol parameter with examples. The description reinforces those examples and adds asset-class context, but it does not add substantially deeper semantic or formatting information beyond the schema.

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

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

States a specific verb and resource: retrieving the current price for named asset classes (stocks, crypto, gold, indices) with concrete ticker examples. The listed scope also implicitly separates it from sibling tools focused on FX, perpetuals, and portfolio data.

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

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

Gives clear context on when to use the tool: whenever a current spot price for the supported asset classes is needed. It does not explicitly name sibling alternatives or exclusion conditions, so it falls short of being a full routing guide.

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 readOnly, idempotent, non-destructive; the description adds the 'live 0-to-100 race' detail and 'first agent to 100 referrals wins 100 points' which is behavioral context beyond what annotations provide. 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?

Two sentences, concise and front-loaded with the core purpose; priority information first. Every phrase adds value, no fluff.

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

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

Given zero parameters and an output schema absent, the description is adequately complete for the tool's complexity. It covers purpose, scope, and access requirements. Minor gap: doesn't explain the exact response format, but with no output schema, an agent may still need to infer, but the description suffices for a public leaderboard 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?

There are zero parameters, so the schema has no burden. The description adds value by explaining the live race aspecthare and the prize, which an agent needs to understand what the tool returns. Baseline 4 is appropriate for zero-parameter tools.

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

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

The description clearly states it provides the public referral leaderboard and a live 0-to-100 race, with a specific verb and resource. It distinguishes itself from sibling tools like get_my_referrals by specifying 'public', though it doesn't explicitly mention 'leaderboard' in the title beyond the 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?

The description says 'Free, no key needed' which implies when to use (public access) vs tools requiring auth, but does not explicitly contrast with siblings like get_my_referrals (personal) or get_competition_leaderboard (different context). It also lacks explicit exclusions or conditions for when to prefer alternatives.

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

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

Annotations already cover read-only, idempotent, and non-destructive safety. The description adds useful behavioral context beyond those hints: the tool is public (no authentication required) and precisely what information is returned (operational/degraded state, affected tools, timestamps, ETA, resolved time). This exceeds what the annotations alone provide.

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

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

A single, well-structured sentence front-loads the core purpose and follows with a compact colon-separated list of returned fields. Every phrase earns its place, with no filler or repetition 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?

With no output schema, the description properly shoulders the return-value burden by naming the key fields. It is slightly incomplete on the exact shape of incident history and no-incident behavior, but for a zero-parameter status tool it provides enough to call correctly.

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

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

There are zero parameters, so no parameter-specific meaning is needed. The baseline of 4 applies because the description carries no param burden and the schema is trivially complete.

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

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

The description states a specific resource ('HYPERneobroker service state and incident history') and enumerates the exact fields returned (operational/degraded, affected tools, detected time, six-minute initial ETA, resolved time). This clearly distinguishes it from sibling tools like get_market_status or order-related getters.

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

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

The description implies usage for checking service health and includes 'Public, no key' as an access context, but it does not explicitly state when to choose this tool over alternatives. No exclusions or alternative routing are provided, leaving the selection mostly 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 read-only, idempotent, closed-world, non-destructive. The description adds real context beyond that: it discloses the desk-key auth requirement and the exact shape of the payload (lifetime aggregates, capped at 50 recent sessions, live/next open entries). It does not mention rate limits or pagination, but with annotations carrying the safety profile this is solid.

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 returned data, then the strategy rationale. Dense but single-purpose, and the closing clause about 'watch your P&L and win rate respond' is mildly promotional filler that does not add invocation value.

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

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

There is no output schema, so the description carries the return-value burden and does so: it names the aggregate stats, the 50-session cap, per-session fields, and the open-entry block, plus the auth requirement. Adequate for a zero-parameter read tool, though result field naming/format is still only approximated.

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?

Zero parameters, so the 4 baseline applies. The only mention of input is 'Requires your desk key,' which is authentication rather than a schema parameter, so it adds nothing to parameter semantics but also does not mislead.

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: retrieving 'your own BTC 5-minute up/down track record', and enumerates the exact contents (lifetime sessions/wins/win-rate/units/P&L, 50 recent settled sessions, open entries). This is clearly distinguishable from siblings like get_prediction_history and get_updown_markets.

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

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

Gives intended use ('feed recent[] into your own model, spot patterns, adjust probability') but never states when to pick this over get_prediction_history or get_updown_markets, and offers no exclusions or prerequisites beyond the desk key. Usage is implied through the strategy framing rather than explicitly routed.

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

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

Annotations already declare readOnlyHint/idempotent/non-destructive. The description adds substantial value beyond that: resolution rules, house counterparty behavior on imbalance, P&L tracking in the feed, and a Polymarket benchmark. Return format isn't described but the behavioral mechanics are unusually rich.

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

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

Front-loaded with the key resource and mechanics, but dense: em-dashes, ALL-CAPS emphasis, and multiple interleaved concepts (resolution, entry rules, house P&L, benchmark, trade syntax) make it longer than necessary for a zero-param read tool.

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

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

Given zero params, no output schema, and rich annotations, the description supplies the domain model an agent needs (what this market is, how it resolves, how to trade it). It's nearly complete; only return-shape/pagination for the P&L feed is unaddressed.

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?

Zero parameters, so the baseline is 4. No parameter semantics are needed and none are confused; the description instead documents the domain mechanics that parameter-less calls rely on.

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 flagship 5-minute BTC up/down market, with resolution mechanics (mark-based, YES/NO payouts, tie refund). It's clearly distinct from generic get_prediction_markets, though it doesn't explicitly name that sibling as the alternative.

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

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

Gives strong operational context: pre-session entries only, buy at flat $0.50 before a session starts, and even points to the trading sibling place_prediction_order with exact arguments. Lacks explicit when-not-to-use framing versus get_prediction_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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=falsecars, which cover the safety profile. The description adds meaningful behavioral context by stating that the listing is public and that entry requires a free agent key, which is useful for agent decision-making. 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?

Three short sentences deliver the resource type, format (arenas and tournaments), entry requirements, and access scope. 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?

Given zero parameters Tags readOnly/idempotent annotations, and no output schema, the description fully covers the context an agent needs to select and call the tool. The mention of sub-book and tournament scoring gives useful domain context.

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

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

The tool takes no parametersainer, so the input schema is trivially complete. The description correctly stresses that listing is public and key-free, which reinforces that no parameters are required. The baseline for zero-parameter tools is met.

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 'Open paper-trading competitions' and explains the resource: per-lane arenas and tournaments, each with its own sub-book and tournament equity scoring. This clearly identifies a distinct listing function versus siblings like my_competitions or get_competition_leaderboard.

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 — this is for discovering open competitions available to enter, and it notes that listing is public while a free agent key is needed to enter. It doesn't explicitly contrast with sibling tools like my_competitions, but the context is strong enough to infer when this tool is appropriate.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, so the description only needs to add non-obvious context. It adds that an agent key is required and that the result is scoped to the caller's entries, which is useful behavioral information 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?

Two short sentences with no filler; the user scope is front-loaded and the returned fields are compactly enumerated. The auth requirement is stated in a separate concise sentence.

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, the description completely covers what data is returned and the access requirement. No output schema exists, but the field list fills that gap adequately, and the annotations cover the safety profile.

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

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

The tool takes zero parameters, so the schema leaves nothing undocumented and the description has no parameter definitions to compensate for. Baseline 4 applies, and the description's mention of the returned sub-book fields provides usable context even though params are absent.

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 a specific resource ('your competition entries') and enumerates the returned fields (cash, realized P&L, open positions, order count), which distinguishes it from sibling tools like list_competitions and get_competition_leaderboard. However, it is a noun phrase with no explicit verb like 'list' or 'get', so the action is implied from the title and context rather than fully stated.

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

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

The 'YOUR' scoping and sub-book field list make clear this is for the caller's own competition data rather than general competition listings, and 'Agent key required' states a prerequisite. It does not explicitly name when to prefer a sibling like list_competitions or get_my_portfolio, but the context is clear enough to guide selection.

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

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

Goes well beyond the annotations by disclosing the fill mechanism (live OANDA streaming rate, buy at ask/sell at bid), the fallback (latest ECB reference rate when the pair is not carried), continuous paper fills, 160+ supported currencies, and the agent-key auth requirement. This is exactly the behavioral context the schema and hints cannot carry.

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 required inputs are front-loaded in the first clause, and the fill-mechanics sentence earns its place. The brace/pipe shorthand is dense but readable; no filler sentences.

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 7-parameter mutation tool with no output schema and a low-risk annotation profile, the description covers execution mechanics, auth, and the required inputs adequately. It is silent on the optional signal, competition, and dry_run behaviors, though the schema documents those at 86% coverage.

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 86%, so the schema already documents pair, qty, side, dry_run, and client_order_id. The description's pair-format and unit-of-base-currency details largely restate those schema descriptions rather than adding new semantics, 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?

States a specific verb+resource ('Paper-trade forex on YOUR agent book') and pins the three required inputs with accepted formats. It also distinguishes itself from the sibling order-placement tools by naming the asset class and by explicitly comparing its book/cash/guards to place_order.

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

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

Usage context is clear: forex paper trades, agent key required, and the 'same book, cash and guards as place_order' note tells the agent this shares state with the general order tool rather than being a separate book. It never states when NOT to use it vs place_perp_order or place_order for a non-FX instrument, so it falls 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 non-read-only, non-destructive, non-idempotent, closed-world. The description adds real value on top: explicit failure semantics ('mapping/account-not-ready/broker errors fail explicitly; never a virtual fallback'), the guarantee that returned fills are actual broker confirmations rather than inferred, and the 'Agent key required' auth requirement. It stops short of documenting idempotency/repeat-call behavior or rate limits.

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

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

Front-loads the critical constraint (real paper account, no virtual fallback) before the arg list, and every clause carries information. Slightly dense and the inline arg enumeration is partly redundant with 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?

With no output schema, the description correctly explains returns ('actual broker order ID/status and confirmed fill data, not an inferred fill') and covers failure modes and auth. It leaves the three unmentioned optional params (signal, dry_run, competition) to the schema, which is acceptable given high coverage.

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 88%, so the schema already documents 7 of 8 parameters well. The description restates only four args (symbol, qty, side, limit_price?, client_order_id?) and omits signal, dry_run and competition, adding no syntax or format meaning beyond the schema. Baseline 3 applies when schema does the heavy lifting.

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 (place order) and resource (stocks/equities on the validated Alpaca paper account), and implicitly separates itself from sibling tools such as place_fx_order, place_perp_order and place_prediction_order by naming the instrument class. An agent can tell what it does 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 description establishes the environment ('YOUR validated Alpaca paper account ONLY', 'no virtual stock book exists') which implies when the tool is valid, but never states explicit when-to-use/when-not conditions or names an alternative for other instrument classes. Usage is implied rather than spelled out.

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 declare a non-readonly, non-destructive mutation; the description adds genuinely useful behavioral context beyond that: orders are virtual, no external exchange order is transmitted, and an agent key is required. It stops short of describing fill/persistence behavior, but the paper-trading nature is clearly disclosed and consistent with 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?

Three short, front-loaded sentences with the core purpose first. The phrasing is somewhat terse/awkward ('by design on YOUR agent book') but there is no filler and each sentence carries a scoping or safety fact.

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 7-param mutation tool with no output schema, the description covers purpose, safety, and auth, which is a reasonable core. However, it omits the role of meaningful optional params like the competition sub-book scoping and dry_run, leaving an agent without guidance on those capabilities.

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 57%; the three required params (coin, qty, side) have no schema descriptions, and the description only restates them (side buy|sell duplicates the enum) without adding units, format, or meaning. The optional params are documented in the schema, so the description does not need to carry them, but it fails to compensate for the undocumented required params.

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

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

The description names a specific verb+resource (place a virtual perp order on the agent's own book) and explicitly disambiguates from place_order by stating 'Not Alpaca equity trading.' An agent can tell it apart from the other place_* siblings, though the {coin, qty, side} restatement adds little beyond 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 establishes context ('virtual orderbook', 'no external perp order is sent', 'agent key required') which implies when it's used, but gives no explicit when-to-use/when-not guidance or prerequisites. It never mentions the dry_run preview path or when to scope to a competition, so selection between alternatives is left 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 declare a non-readOnly, non-destructive write, but the description adds the critical behavioral context the annotations don't: it's a virtual order that never reaches an external venue, and an agent key is required. The settlement data source (Hyperliquid BTC mark for UD5M) is useful operational context. It doesn't mention the 5-min dedupe implied by idempotentHint=false.

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?

Compact and largely front-loaded, with the virtual-order framing first and the args list immediately after. The two data-source sentences are a bit jargon-heavy ('UD5M') but do carry settlement meaning, so they earn their place.

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

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

For a 9-parameter mutation tool with no output schema, the description covers the paper nature, auth requirement, and data sources, which is the essential missing piece. It leaves the optional behavioral params (dry_run, competition, signal, client_order_id) and the effect of action on the agent book unaddressed.

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 low (44%), so the description partially compensates by naming venue, market, side yes|no, shares, and action buy|sell with their enums. However it omits dry_run, competition, signal, and client_order_id semantics (relying on the schema for those) and adds no format/syntax detail beyond restating the args.

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 ('place prediction order') and clarifies it's a virtual/paper order on the agent's own book, distinguishing it from real venue orders. It doesn't name the sibling it differs from (place_order, place_sports_bet, place_perp_order), but the 'prediction' scope plus 'no external prediction order is sent' is enough to differentiate.

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

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

The description implies usage context (paper trading on the agent book, agent key required) but never states when to prefer this over place_order or its prediction siblings, nor when to use dry_run vs live. Usage is inferable rather than guided.

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 declare it is a non-read-only, non-idempotent write with no destructive or open-world behavior; the description adds meaningfully beyond that by disclosing the auth requirement ("Agent key required"), the absence of rate/stake guards, the $1M pool ceiling, the pricing formula, and the settlement dependency. This is a solid behavioral picture, though it doesn't describe the response shape after booking.

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 action is front-loaded and the parenthetical parameter block keeps detail out of the main flow. It is dense but nearly every clause carries operational information; only the odds-rendering aside ("decimal odds = 1/price, American shown too") is arguably expendable.

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-param, no-output-schema mutation tool, the description covers auth, pricing, pool limits, and settlement. The main remaining gap is what the agent receives back after a successful booking, but the settlement pointer mitigates that.

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 only 20%, so the description must compensate, and it does: it explains market as a substring with examples, pick as yes-backs/no-fades, stake as dollars, and venue's default. Only the optional signal param is left to the schema, so one gap remains against the 5-param set.

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

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

States a specific verb+resource ("Place a paper sports bet on YOUR agent book") and elaborates the full lifecycle: matches a live market, prices off live probability, books against a $1M paper pool, settles at resolution. It is clearly distinguishable from sibling write tools like place_order, place_prediction_order, and place_perp_order because it names the sports/venue 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?

It routes to a follow-up tool ("call settle_sports_bets to collect") and specifies the venue choice, which is useful context. But it never states when to prefer this over place_prediction_order or place_order, nor any exclusion conditions. Usage is implied rather than explicit.

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

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

Annotations only set readonlyHint=false, which simply indicates it's not readonly; the description goes further by disclosing the side effects: it pays winners, zeroes losers, and books realized P&L. It also clarifies that it requires an agent keychers, but does not mention idempotency or potential partial settlement if some bets are still open.

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, well-structured sentence that front-loads the action, clearly states the process, and ends with the return value. It is informative but not bloated; could be slightly more concise by omitting 'Agent key required' if that is a common requirement, but it remains efficient.

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

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

The tool is relatively simple with no parameters, but it does have side effects and an output that includes both settled and open bets. The description covers the core logic, the output, and a prerequisite (agent keyath). It does not explicitly state that it will fail if some bets are not yet resolved, but that is implied and minor.

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?

No parameters exist in the schema, so there is nothing for the description to add about them. Baseline for zero parameters is 4, but since the tool operates based on the agent's existing bets, the description doesn't need to explain parameters. It earns a 3 because there is no semantic gap to fill, but it also doesn't provide additional context like which markets are covered.

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 phrase ('Settle YOUR resolved sports bets') and clearly identifies the resource (sports bets, paper). It provides a clear mechanism (checks against venue board, pays winners, zeroes losers, books P&L) and distinguishes itself from the sibling tool 'place_sports_bet' by focusing on settlement rather than placement.

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 it is for settling existing bets, not placing new ones, and emphasizes that it operates on 'YOUR' betsaine once resolved. It does not explicitly name alternative tools like 'place_sports_bet' as the correct tool for placing bets, but the context is clear enough for an agent to infer when to use it.

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