SimianX AI

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered structurally. The description contributes nothing beyond that — no result shape, no recency window, no limit/pagination behavior — so it earns only a minimal score despite the lower bar.

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 short and front-loaded, but the brevity is the product of under-specification rather than economy. Two words carry no actionable information beyond the name/title already shown to the agent.

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

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

The tool is trivial to invoke (no params) and fully annotated, so invocation risk is low. However, with no output schema and a family of near-identical listing siblings, the description leaves the resource identity and return content entirely undefined.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter-level gaps exist.

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

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

Tautological: description restates name/title.

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

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

No indication of when to call this versus the many other listing tools in the sibling set. The agent must guess whether this returns live analysis runs, autopilot runs, or something else, and there are no exclusions or alternatives named.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the write-once nature is covered. The description adds genuinely new behavioral context beyond that: the call consumes metered points scaled by model, and the answer is not returned inline but must be fetched via get_deep_thread. It omits any detail on what the immediate response contains or partial-failure behavior.

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

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

Front-loaded purpose is good and the whole thing is short, but 'Uses points' is immediately restated by the parenthetical '(uses points, metered on the models used like the website)' — pure redundancy. Trimming that would make it tighter without losing 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 partially compensates by telling the agent answers come from get_deep_thread, which is the key missing return-value fact. However it says nothing about what the immediate call returns, authentication/point-balance prerequisites, or failure modes, leaving real gaps for a metered, mutating call.

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 67% and the description supplies essentially no parameter-level information. 'message' has no schema description and the description never clarifies it is the follow-up question; 'analysis_id' and 'mentions' are already documented in the schema, so the description adds nothing for them. The 2000-char message limit and the 3-seat mentions cap go unexplained.

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

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

States a specific verb and resource: 'Ask a follow-up question about a finished deep research run.' The word 'finished' implicitly separates it from start_deep_analysis, and pointing at get_deep_thread distinguishes the asking action from the reading action. It stops short of explicitly naming which sibling to use instead when the run is not finished.

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

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

Gives a clear prerequisite ('a finished deep research run') and routes the agent to the alternative for retrieving results ('read the answers with get_deep_thread'). No explicit when-not-to-use or error-condition guidance, so it lands just below the top tier.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, so the danger profile is covered. The description adds genuine value beyond that: execution always happens at the server's price, stocks are long-only, and intraday entries require the market to be open. It still doesn't say what a close/reduce destroys or whether changes are reversible.

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

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

Two sentences with no filler: the core purpose is front-loaded, followed by the operating constraints. The action enumeration is long and largely redundant with the enum, which costs a point, but nothing is padded.

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

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

For a 12-parameter, multi-action destructive mutation with no output schema, the description gives constraints but omits which parameters apply to which action, permissions/auth requirements, and what a call returns (e.g., resulting position or order id). The per-action param hints live in the schema, but the description alone is only partially 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 a middling 58%, with several parameters (stop_loss, take_profit, order_type, side, quantity) undocumented. The description re-lists the action enum values, which duplicates the schema rather than adding meaning, and only 'always at the server's price' adds anything beyond the structured fields. It does not compensate for the coverage gap.

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

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

States a specific verb and resource ('Change the autopilot's paper position by hand') and enumerates the nine actions, which is enough to distinguish it from config-oriented siblings like update_autopilot or start/stop_autopilot. It never names a sibling explicitly, so it stops short of the top band.

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 supplies real usage constraints ('Stocks are long only', 'intraday stock entries need the market open') and implies this is a manual override ('by hand'). However, it never says when to prefer this over update_autopilot or the automated autopilot flow, so the when-to-use vs alternatives is left implicit.

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 and destructiveHint=false, but the description adds zero behavioral context: no pagination behavior, no cursor semantics, no rate limits, no indication of what the history contains or how it is ordered. For a history-listing tool the description carries no additional information at all.

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 words is not conciseness but under-specification. There is no structure, no front-loading of scope, and nothing that earns its place because there is essentially no content.

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

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

A five-parameter tool with a required id, a cursor, a limit, and a filter, with no output schema and no annotations beyond the safety profile, is left almost entirely undocumented. An agent cannot reliably invoke this correctly from the description alone.

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 roughly 80%, but the descriptions themselves are near-useless: 'id' is documented as 'id', 'include' as 'text', and 'agent' has no description at all. The tool description compensates for none of this, so the meaning of limit, before, agent, and include remains unclear.

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?

Tautological: description restates name/title.

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

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

There is no guidance whatsoever on when to use this tool, when not to, or which sibling to prefer. An agent must guess between this and analysis_live_list, autopilots_logs, and list_deep_analyses with nothing to go on.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds only the 'stopped' state qualifier; it says nothing about whether archiving is reversible, what it hides, or whether the autopilot must be stopped first as a hard requirement. There is no contradiction with the annotations, but the added value is minimal.

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?

At five words it is maximally short and front-loaded with no padding, but this is under-specification rather than disciplined concision. There is no structure to speak of because there is only a fragment.

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, open-world operation with no output schema, an agent needs more: whether the id is an autopilot id, whether the autopilot must be stopped beforehand as a requirement, and whether the archive can be undone. None of that is present, leaving the definition incomplete for a mutation tool.

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

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

Schema description coverage is 100% for the single 'id' parameter, so the schema carries the parameter burden and a baseline of 3 applies. The description adds no meaning about what the id identifies or where to obtain it, so it neither helps nor hurts.

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?

Tautological: description restates name/title.

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 word 'stopped' implies a precondition but never states it as guidance. There is no indication of when to archive versus stop_autopilot, update_autopilot, or delete, and no mention of alternatives among the many sibling autopilot 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?

The description adds nothing beyond the annotations, which already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false. The safety profile is therefore known from structured data alone, but the description contributes no extra behavioral context such as log volume, pagination, or retention.

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 text is short but that brevity reflects under-specification rather than conciseness — it is a title, not a description. There is nothing to be front-loaded because no substantive content exists.

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

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

For a read-only tool taking a single id, the definition still omits what the log covers, what the id refers to, and any hint about the returned entries. Annotations carry the safety profile, but an agent cannot tell what invoking this will actually produce.

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 baseline of 3 applies; the schema nominally documents 'id'. However, that schema text is merely 'id' and the description does not clarify what the id identifies (an autopilot?) or its expected format, so no meaning is added.

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

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

Tautological: description restates name/title.

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, when-not-to-use, or alternative-tool guidance of any kind. An agent has no basis for choosing autopilots_logs over get_autopilot_events or get_autopilot.

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 cover the mutation/non-idempotent/open-world profile, and the description adds meaningful context beyond them: that this is a recurring scheduled process whose every cycle consumes points (metered by model tier), and that the Decision agent can manage a paper position. The recurring cost is a genuine behavioral disclosure.

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

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

Front-loaded well with the core action in the first clause, but the closing 'Uses points on every cycle. (uses points, metered on the models used like the website)' is redundant, restating the cost point twice in a garbled parenthetical.

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 complex 11-param mutation tool with nested objects and no output schema, it covers scheduling, cost, and where events land, but omits what the call returns (e.g., an autopilot id) and any auth/plan requirements, leaving some gaps for the agent to fill.

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 91%, so the schema already documents nearly all 11 parameters in detail (enums for tier/asset/agents, timeframe lists, webhook shape). The description adds little parameter-specific syntax beyond naming 'symbol' and the paper-position behavior; baseline 3 applies when the 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 and resource: 'Run the four live agents on a symbol on a schedule' plus optional Decision-agent paper position management. Clear what it does, but does not distinguish itself from confusingly similar siblings like start_autopilot and run_autopilot_agent.

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

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

Usage is only implied: the description conveys the scenario (scheduled agent runs) and points to get_autopilot_events for the resulting log. There is no explicit when-to-use or when-not-to-use guidance, and no routing away from the near-identical start_autopilot sibling.

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 nothing beyond the title: no cursor semantics, no timeout/keep-alive behavior for the long-poll, no explanation of what 'include' streamed deltas actually delivers, and no hint that this is a repeated/incremental 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?

It is a single short line, but that brevity reflects under-specification rather than discipline — the entire text is a restatement of the title. Nothing is front-loaded because there is nothing beyond the title to 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?

This is a streaming tool with five parameters (cursor, wait window, type filter, delta/tool inclusion) and no output schema, so the description carries the burden of explaining streaming behavior. It instead repeats the title and leaves the cursor pagination model, the wait semantics, and the long-poll-vs-SSE distinction entirely unexplained.

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 of 3 applies; the schema documents all five parameters. The description adds no meaning beyond the schema, so it neither compensates nor earns more than the baseline.

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

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

Tautological: description restates name/title.

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

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

No guidance is given on when to tail versus fetch events with a sibling tool, nor on how the long-poll mode relates to the SSE mode or when to prefer one. The mention of two modes implies a usage choice but never states the selection criterion, and no prerequisites are given.

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

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

Annotations declare openWorldHint=true and readOnlyHint=false, implying this reaches outside the service and is not a pure read — yet the description says nothing about network dependence, permissions, or side effects, and offers no explanation for why a "PDF report link" tool would not be read-only. It adds zero behavioral context beyond the structured hints, leaving an unexplained gap between the name's read-like framing and the write-like 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 words is short, but this is under-specification rather than conciseness: there is no front-loaded purpose statement, no scope, and nothing that earns its place because almost nothing is said.

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 required-parameter tool with no output schema and ambiguous read/write semantics, the description is completely inadequate — it gives no purpose, no usage context, no parameter meaning, and no return behavior. An agent has no basis for selecting or correctly invoking 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 nominally 100%, but the single parameter's description is just "id", which conveys no semantics — an agent cannot tell whether this is a deep-analysis id, a thread id, or a report id. The tool description does nothing to resolve the ambiguity, so the high coverage number is empty here.

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

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

Tautological: description restates name/title.

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 prerequisites, and no mention of any sibling tool (e.g. get_deep_analysis, deep_events) that might be the alternative. The agent is left to guess entirely from the name.

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

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

Annotations already establish the safety profile (readOnly=false, idempotent=false, destructive=false), lowering the bar. The description adds genuinely non-obvious behavioral context by disclosing that the action "uses points, metered on the models used," which is cost/billing information not present in the structured fields.

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

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

A single front-loaded sentence with the primary action first and the cost caveat parenthetically appended. No filler and nothing wasted.

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

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

For a one-parameter resume action with annotations covering the safety profile and no output schema, the description is minimally adequate but omits what state to expect, error conditions when resuming a non-paused run, and any auth/prerequisite detail.

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% for the single id parameter, so the schema already carries parameter documentation. The description adds no meaning about the id (e.g., that it is the run id) beyond what the schema provides, 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 ("Resume a paused run") that an agent can distinguish from start_deep_analysis or get_deep_analysis. However it does not explicitly name a sibling or clarify how it differs from starting a new run, so differentiation is implicit 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 phrase "a paused run" implies the precondition, but there is no explicit when-to-use versus alternatives such as start_deep_analysis or deep_stop, and no guidance about what to do if the run is not paused. Usage is inferable but not 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 already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description "Stop a run" adds nothing beyond that — no mention of whether the stop is immediate, reversible, or what happens to an in-flight run. No contradiction with annotations (stop is a write, consistent with readOnlyHint=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?

It is short, but this is under-specification rather than conciseness — three words that merely echo the name. Nothing is front-loaded because there is no substantive content to order.

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

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

For a mutating control tool with an out-of-band 'id' argument, the agent needs some notion of what a run is and what stopping it entails. Annotations cover safety, but the description provides no operational context and there is no output schema to fall back on.

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% for the single required 'id' parameter, so the baseline is 3. The description adds no meaning about what the id identifies or where it comes from, but the schema carries 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?

Tautological: description restates name/title.

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

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

There is no guidance on when to use this tool, when not to, or which sibling to prefer. With stop_autopilot present in the sibling list, the absence of any disambiguation leaves the agent to infer the choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds two useful traits beyond them — a hard 20-item bound and 'status only' (no message bodies) — but omits pagination behavior and what a status value contains.

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

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

A single front-loaded clause with zero filler, but the brevity comes partly from simply echoing the title rather than from tight authoring.

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 0-param read-only list tool the annotations do much of the work, but with no output schema the description should say more about what a 'status' entry contains and whether results are ordered or paginated; as-is it is minimally sufficient.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to carry; baseline 4 applies. Schema coverage is moot at 0 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?

Tautological: description restates name/title.

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

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

There is no when-to-use guidance and no mention of the sibling send_feedback as the counterpart write tool. The parenthetical 'we do not reply' is a limitation notice, not usage direction.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value by enumerating the returned payload (plan, points left, limits, budgets), which partly compensates for the absent output schema, but it says nothing about auth scoping, error behavior, or freshness/rate considerations.

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

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

A single front-loaded sentence with no filler; the resource and its contents lead the clause. Nothing could be trimmed without losing 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?

A low-complexity, zero-parameter read with annotations covering the safety profile, so little prose is owed. Since no output schema exists, the description usefully names the key response fields; only the sibling-overlap question with usage_get is left unresolved.

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

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

The tool takes zero parameters, so the baseline is 4 under the scoring rules. The description correctly implies implicit scoping to the API key rather than requiring a caller-supplied identifier, which is the only semantic point that matters here.

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

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

The title supplies the verb ('Get') and the description names the specific resource and its contents (plan, points left, limits, budgets) tied to the API key. It is immediately clear this retrieves the caller's own account rather than, say, an autopilot or sector. It stops short of explicitly distinguishing itself from the sibling usage_get, which plausibly also surfaces limits/points.

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 statement of when to call this versus alternatives, and the obvious overlap candidate usage_get is not addressed. For a simple no-argument getter the implied usage is discoverable from the name, but the description contributes no routing guidance at 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 declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, covering the safety profile. The description adds that the payload includes status, configuration, and an event cursor, which is useful return-content context. However, it omits error behavior and pagination of the cursor.

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 tight sentence that front-loads what is returned. No waste, though it is terse enough that it leaves out potentially useful routing or failure details.

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

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

With no output schema, the description usefully names the returned fields, and with full schema coverage the single parameter is covered. Still, for a read against an open-world target it lacks failure-mode or usage guidance, leaving a modest 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?

Schema coverage is 100% and there is a single UUID-typed autopilot_id, so the schema fully documents the parameter. The description adds no format or semantic detail beyond it, which is the expected baseline when the 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 (get) and resource (one autopilot) and clarifies it returns status, configuration, and event cursor. It distinguishes retrieval from the many autopilot mutation siblings (update, delete, start, stop), though it does not explicitly contrast with list_autopilots or get_autopilot_events.

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

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

No explicit when-to-use guidance or prerequisites. The agent can infer it retrieves a single autopilot by ID, but nothing says when to prefer this over list_autopilots or get_autopilot_events, nor what happens if the ID is unknown.

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 that this is a safe, read-only, idempotent operation. The description adds meaningful behavior beyond that: the long-polling contract (wait up to 25 s) and the cursor-based incremental retrieval pattern. It does not cover error behavior or cursor expiry, but it adds real value over 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 tightly written sentences with zero waste. The purpose is front-loaded, and the second sentence earns its place by explaining the cursor workflow. No redundancy or filler.

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

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

With no output schema, the description usefully states that the initial response contains latest events and a cursor, and explains how to continue. It leaves out details like event object structure, limit interaction, and type filtering, but the schema covers those parameters and the core polling contract is complete enough for an agent to call the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters and the baseline is 3. The description adds meaning by explaining the interaction between after and wait: passing the cursor as after and waiting yields only what happens next, which is a semantic combination not fully spelled out in the individual schema descriptions.

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

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

The description identifies a specific resource (the autopilot's event log) and enumerates what it contains: analyses, signals, position changes, actions. This is clear enough to distinguish it from a general log or positions tool, but it does not explicitly name or contrast itself with siblings such as autopilots_logs or get_autopilot_positions.

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

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

It gives clear operational context for the two modes of use: omit after to get the latest events plus a cursor, or pass that cursor as after with wait to receive only subsequent events. It does not, however, mention when to prefer this tool over alternatives like autopilots_logs or get_autopilot_positions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no behavioral context beyond stating what is returned, which is a modest addition.

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 concise sentence with zero waste, front-loading the resource. Appropriate for a simple getter.

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

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

Given the simple resource and 100% schema coverage for the single param, the description is minimally adequate. However, without an output schema, it could better describe what 'paper positions and their operations' entails, and it offers no usage context.

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

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

Schema coverage is 100%, so the single parameter's meaning is fully documented in the schema. The description adds no additional parameter semantics, which is appropriate as baseline 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?

The description states a clear verb+resource: retrieving an autopilot's paper positions and their operations. It does not differentiate from siblings like get_autopilot or get_autopilot_events, but the resource is specific enough to be distinct.

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

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

No when-to-use guidance is provided. The description doesn't explain when to call this vs get_autopilot or list_autopilots, nor does it mention any prerequisites or context.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral fact beyond annotations: the cost (0.2 points per call). It says nothing about pagination behavior or result size limits, which the 'before' and 'limit' params imply matter.

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

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

Two short sentences with zero filler, resource stated first and the cost note isolated in parentheses. Nothing is padded or repeated from the title.

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

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

For a 4-parameter market-data tool with no output schema and 75% schema coverage, the description is minimally adequate: it identifies the resource and the cost but omits timeframe semantics, pagination via 'before', and any sense of the returned candle shape. An agent could call it, but without full confidence about pagination or timeframe defaults.

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 75%, with limit, before, and symbol documented in the schema itself; timeframe is an enum but has no description anywhere. The description's 'coin or pair' phrasing loosely reinforces the symbol parameter but adds no syntax or format detail 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 the specific resource (OHLCV candles) and the input domain (coin or pair), which clearly separates it from get_crypto_quotes and get_crypto_indicators. The verb is only implied by the name rather than spelled out, and no sibling is named explicitly, so it falls just short of a 5.

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

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

There is no guidance on when to choose this over get_crypto_quotes, get_crypto_indicators, or market_status, and no mention of timeframes or use cases. The agent must infer usage entirely from the name and schema.

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, destructiveHint=false and openWorldHint, so the safety profile is fully covered structurally. The description's only added behavioral fact is the cost signal '(0.3 points per call)', which is genuinely useful but leaves return shape and any rate/scope constraints unstated.

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 clauses, front-loaded with the resource and the indicator categories, with the pricing note appended rather than buried. Nothing is wasted, though the parenthetical could carry more substantive detail.

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

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

With no output schema, the description is the only source for what comes back, and it says only 'trend, momentum, levels' without naming indicators, units, or response structure. For a simple two-parameter read tool this is defensible but leaves real gaps.

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

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

Schema coverage is 50%: symbol is documented as 'Coin (BTC) or pair id', and the description echoes that with 'coin or pair'. The timeframe parameter is only an enum with no description in either place, and no default or resolution semantics are given, so the description does not compensate for the gap. Baseline 3 for partial coverage.

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

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

States a specific verb+resource: an indicator snapshot covering trend, momentum and levels for a coin or pair. That distinguishes it reasonably from siblings like get_crypto_quotes and get_crypto_candles, though it never names those alternatives explicitly.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of when an agent should prefer this over get_crypto_quotes, get_crypto_candles or a live analysis tool. The reader must infer the context entirely.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the bar is lower. The description still adds genuinely useful information beyond them: the per-call cost ('0.1 points per call') and the 120-coin batch ceiling, which an agent must know for budgeting and batching. It says nothing about the response shape, though no output schema exists to carry that.

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 fragments, front-loaded with the capability ('Latest prices for up to 120 coins') and trailed by the cost note. Every word earns its place; there is no filler or redundancy.

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

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

For a one-parameter quote tool with no output schema and no nesting, this is adequate but leaves gaps: the description never hints at what a quote contains (price, timestamp, change) or how unknown/too-many symbols are handled. An agent can call it correctly but cannot anticipate the return payload.

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 there is a single parameter, so baseline would be 3. The description adds a real constraint not present in the schema — the 120-symbol cap on the symbols list — which is meaningful for how an agent chunks its requests.

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 ('Latest prices') and a clear scope bound ('up to 120 coins'), so an agent knows exactly what comes back. It does not, however, differentiate itself from siblings like get_crypto_candles or get_crypto_indicators, which also return crypto price 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?

'Latest prices' implies a real-time snapshot rather than historical series, which lets an agent infer this is the right tool for current quotes. But there is no explicit when-to-use, when-not-to-use, or named alternative such as get_crypto_candles for time-series data, so the guidance remains implied.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, openWorldHint, destructiveHint=false), so the bar is lower. The description adds genuinely new behavior: the run is asynchronous and must be polled until a terminal status, and it discloses which outputs come back. It omits any rate-limit or timeout guidance, which would have pushed this higher.

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, zero filler, and the return contents are front-loaded before the polling instruction. 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 must carry the return contract, and it does name the three key fields (state, verdict, trade plan) plus the terminal-status behavior. It could go slightly further by enumerating status values (e.g., pending/running/done) so the agent knows exactly when to stop polling.

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

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

Schema description coverage is 100% with only 2 parameters, so the schema already documents analysis_id (from start_deep_analysis) and the include enum. The description adds no syntax, format, or semantic detail beyond what the schema states, 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?

Names a specific resource (a deep research run) and enumerates the returned artifacts (state, verdict, trade plan), so the agent knows this is a retrieval/status tool rather than a kickoff. It does not explicitly distinguish itself from siblings like list_deep_analyses, get_deep_thread, or ask_deep_analysis, so the sibling differentiation is left to inference.

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

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

'Poll until status is done' is a concrete, actionable usage instruction that tells the agent this is an asynchronous status endpoint requiring repeated invocation. What's missing is routing guidance: no mention of list_deep_analyses to discover ids or get_deep_thread for the full transcript instead of the summary.

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 and destructiveHint=false, so the safety profile is covered. The description adds that the payload is the questions and the committee's answers, which is useful content context, but says nothing about ordering, pagination, or behavior when no follow-ups exist. Some value added beyond annotations, hence a 3.

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

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

A single short sentence with no filler, and the key content ('questions' and 'answers') is front-loaded. It is a fragment without an explicit verb, but it wastes nothing.

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

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

For a one-parameter read tool with no output schema and full annotation coverage, the description is minimally sufficient but skips usage routing and return-shape detail (no pagination or ordering). It tells the agent what the data is but not how to decide to call it or what to expect structurally.

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 analysis_id parameter is documented in the schema as 'Deep research id'. The description adds no format, source, or semantics beyond what the schema provides, so the baseline 3 applies.

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

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

The description reads as a noun phrase ('Questions asked about a deep research run and the committee's answers') rather than a specific verb+resource, so it only implicitly conveys that it retrieves a follow-up Q&A thread. It does identify the resource content, but gives no differentiation from siblings like get_deep_analysis or ask_deep_analysis. Adequate but vague on the action.

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

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

There is no statement of when to use this tool versus alternatives. The presence of ask_deep_analysis (which likely submits questions) creates a natural contrast the description never addresses. Context is entirely absent.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavior beyond that: the wait-based polling model and the re-poll condition while queued/running. It stops short of describing the shape of the returned status values, which would help an agent parse results.

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

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

Two tight sentences, front-loaded with what the tool returns and followed by the polling mechanic. No filler.

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

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

For a polling tool with no output schema, the description covers what is returned ('status and results') and how to drive the polling loop, which is the key operational knowledge. It could say more about what a terminal status looks like versus the intermediate queued/running states, but nothing critical for invoking it is missing.

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

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

Schema description coverage is 100%, so the schema already documents run_id, wait (0-25, default 0) and include. The description's wait guidance largely restates the schema definition, and it never mentions include ('text: full write-up'), so it adds no meaning beyond the structured fields. Baseline 3 applies.

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

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

States a specific resource and scope: 'Status and results of a run started with run_live_analysis.' It anchors the tool to its sibling run_live_analysis (the starter) and distinguishes itself as the status/result reader without needing to open either schema.

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

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

Explicitly tells the agent to pass wait (up to 25s) to block until completion and to re-call while status is queued or running — this is real polling guidance. It lacks an explicit 'do not call before starting a run' exclusion, but the linkage to run_live_analysis makes 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 declare readOnly/openWorld/idempotent/non-destructive, so the safety profile is covered. The description still adds real behavior: results are scored with per-article value tiers and sentiment, ordered newest first, and cost 0.5 points per call — a billing disclosure not present in any structured field.

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 with the core identity front-loaded, then filtering, then pagination, then cost. No filler and nothing buried at the end.

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 seven optional filter parameters, the description correctly sketches the return shape (article with symbols, value, sentiment) and the pagination model, which is what an agent needs to iterate pages. Minor gaps remain around result volume/rate limits beyond the per-call point cost, but the essentials are present.

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

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

Schema coverage is 86%, so the schema already documents asset, limit, since, cursor, symbols, min_value and sentiment. The description's 'since for new, cursor for older pages' largely restates what the schema says ('next_cursor from the previous answer', 'only items newer than this'), so it adds little beyond baseline.

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

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

States a specific verb+resource ('scored news stream behind Market Pulse') and describes what each article carries (symbols, value, sentiment), which is far more than a restated name. It implicitly separates itself from get_news_article (single article) and news_translate by framing the result as a stream, though it never names a sibling explicitly.

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

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

Gives operational guidance for two parameters ('use since to fetch only what is new, cursor for older pages') but says nothing about when to choose this tool over get_news_article, get_pulse_events, or news_translate. Usage is implied by the news-stream framing rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered structurally. The description adds genuinely useful non-annotation context: the per-call cost of 0.2 points. It does not add anything about rate limits or error conditions, so a 3 is appropriate.

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 tight sentence that front-loads the resource and tacks the cost onto the end. Nothing is wasted; no structural 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?

For a one-parameter read tool with no output schema, the description covers scope, return fields and cost. The only missing piece is pagination/error behavior, which is minor here.

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

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

Schema coverage is 100% and the single parameter is documented as 'Article id from get_news' with a uuid format, so the schema does the heavy lifting. The description only repeats the provenance, adding no new semantic detail. Baseline 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 and resource ('One article from get_news') and enumerates the content it returns (text, symbols, value, sentiment), so an agent can distinguish it from the sibling get_news list tool. It stops short of explicitly naming the contrast, but the singular wording makes the scope clear.

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

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

'from get_news' implies the workflow (call get_news first, then fetch a full article by id), which is usable guidance. There is no explicit when-to-use/when-not statement or alternative named beyond that implication.

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

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

Annotations already declare this is a read-only, idempotent, open-world operation, so the description doesn't need to restate safety. It adds genuinely useful behavior the annotations cannot express: severity is scored 1-4, results are returned newest-first, freshness is throttled on lower plans, and each call costs 0.3 points. Only pagination/return-shape detail is missing.

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

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

Two tight sentences that front-load what the tool returns, then append ordering, plan-based delay, and cost. No filler, no repetition of the tool name.

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

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

With seven optional params and no output schema, the description still conveys the essentials an agent needs: what an event is, its severity scale, ordering, cost, and freshness caveat. Cursor-based paging and the event 'types' vocabulary are left entirely to the schema, which is a minor gap for a list tool.

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

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

Schema coverage is 100%, so the schema already documents asset, limit, since, types, cursor, symbol, and min_severity. The description only restates the severity range and asset scope that the schema defines, adding no syntax or filtering nuance beyond it. 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?

Names a specific resource (Market Pulse events) and defines what they are: sudden price moves and market events on US stocks and crypto. A reader can tell it apart from get_sector_events and get_news by content type, but it never explicitly contrasts itself with the closer sibling get_pulse_summary, so it stops short of the top band.

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 domain described (real-time market movement events), and 'Newest first; delayed on lower plans' hints at freshness expectations. But there is no explicit when-to-use or when-to-prefer-an-alternative steer, leaving the agent to infer it from the sibling list.

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

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

Annotations already declare readOnly, idempotent, openWorld, non-destructive, so the safety profile is covered. The description adds genuinely useful billing context (0.2 points per call), but says nothing about response shape, aggregation window behavior, or freshness, and there is no output schema to fill that gap.

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

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

Two short sentences with the scope statement front-loaded and no filler. It is lean, though the cost parenthetical could be a separate concern rather than part of the purpose line.

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

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

With no output schema and no parameters, the description is the only place an agent can learn what a 'summary' contains, and it only gives the time window. For a low-complexity read tool with rich annotations this is borderline adequate, but richer return-value context would help.

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, which is the baseline-4 case; there is nothing for the description to clarify. Schema coverage is 100% but trivially so.

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

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

The description names the resource (Market Pulse) and the temporal scope (24-hour overview), so an agent knows this returns a recent snapshot. It does not distinguish itself from the sibling get_pulse_events, which likely surfaces related data, so differentiation is missing.

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 statement of when to call this versus get_pulse_events or market_status, and no prerequisites or exclusions. Usage is only weakly implied by the '24-hour' framing.

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 readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so safety and idempotency are covered. The description adds a non-annotation behavioral trait: the cost (0.3 points per call), which is useful. However, it omits pagination/limit behavior and what 'stats' actually contains.

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

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

A single compact sentence listing what is returned plus a cost parenthetical. It is front-loaded and wastes almost nothing, though the grouped phrase 'stats, the coming catalysts, recent events and the largest companies' is slightly dense.

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

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

The tool has 3 params, no output schema, and rich annotations. The description covers what is returned and the cost, but lacks guidance on differentiating from sector siblings and does not explain limit/include behavior; adequate but with clear gaps.

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

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

Schema coverage is 100%, so the schema already documents sector, limit, and include with defaults and bounds. The description adds nothing about parameter semantics; baseline 3 applies when the schema fully carries the parameter burden.

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 the resource (a sector) and enumerates its contents (stats, catalysts, events, largest companies), but 'Get a sector' is essentially a restatement of the name/title. It does not clearly differentiate from siblings like get_sector_calendar, get_sector_events, sectors_stock, or list_sectors.

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

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

There is no guidance on when to use this tool versus the many sector-related siblings. An agent cannot tell from the description why it would call get_sector instead of get_sector_calendar, get_sector_events, or sectors_stock; only the cost hint is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact not in structured data: the cost of 0.3 points per call. However it says nothing about pagination, default window behavior, or what happens to omitted filters.

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

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

Two short sentences, front-loaded with the resource and the key examples, and the pricing note is appended efficiently. Nothing is wasted, though for a 9-parameter tool the brevity borders on under-specification.

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, open-world query tool with no output schema, the description omits default behavior, output shape, and sibling differentiation. The cost note is the only information an agent could not have gotten elsewhere, so the definition is thin relative to the tool's complexity.

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 78%, close to the high-coverage baseline, so the schema carries most of the parameter load (defaults for from/to, limit max, since semantics). The description adds no parameter-level meaning; the PDUFA/examples hint at the 'kind' filter without naming 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?

States a specific resource (dated catalysts in a sector) with concrete examples (PDUFA dates, advisory committees, trial readouts, conferences) that tell the agent what kind of data to expect. It does not distinguish itself from close siblings like get_sector_events or sectors_event, so the agent must infer the boundary.

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 sibling tools (get_sector_events, deep_events) that plausibly overlap. The agent is left to infer the selection criteria entirely from the name.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new context not present in structured fields — the per-call cost of 0.3 points and the provenance of events from primary sources. It omits pagination behaviour despite a cursor parameter, so it stops at minimum-plus.

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 fragments with no filler, and the core scope (events in a sector from primary sources) is front-loaded before the severity and cost asides. It is efficiently sized, though arguably under-specified rather than tightly concise.

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 eight parameters, one required, and no output schema, the description should ideally sketch the returned event shape beyond 'severity 1-4'. The rich schema compensates for much of the gap, but pagination and the relationship to sibling event endpoints remain unexplained.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters, including defaults, ranges and cursor semantics. The description's only contribution is restating the 1-4 severity range, which duplicates min_severity. Baseline 3 is correct when the 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?

The description states a clear resource (events for a sector) plus distinguishing qualifiers: primary sources and severity 1-4. It stops short of differentiating itself from near-neighbours such as sectors_event, get_pulse_events, and deep_events, so an agent cannot tell from text alone which event endpoint applies. Clear but undifferentiated.

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 statement, no prerequisites (e.g. sector slug must come from list_sectors), and no named alternative among the many sibling event tools. Usage is only weakly implied by the phrase 'events in a sector'.

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

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

Annotations already carry the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the bar is low, yet the description adds essentially nothing useful and instead asserts 'the four live agents running on a schedule' — a scope claim that the status/archived parameters below it undermine.

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 short sentence with no filler and no buried preamble. It is efficient, though the brevity comes at the cost of substance rather than by editing out 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 simple two-optional-parameter read tool with no output schema, the description should at minimum clarify scope and usage, but it leaves out when to use it and gives a misleading impression that only running scheduled agents are returned.

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 parameters are already documented, but the description's framing ('four live agents running on a schedule') actively narrows the implied scope in a way that conflicts with the status filter and the archived flag, which is worse than adding nothing.

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?

It implies a listing of the account's autopilots, and the singular sibling get_autopilot gives some contrast, but no explicit verb is used and the qualifier 'the four live agents running on a schedule' is strangely narrow and hard to reconcile with the filtering options. An agent gets the gist but not a clean, precise statement of scope.

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

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

No when-to-use guidance at all, despite many plausible alternatives in the sibling list (get_autopilot, autopilots_analyses, autopilots_logs, autopilot_action). Nothing tells the agent when to reach for this versus a more specific autopilot tool.

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

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

Annotations already supply the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=true), so the description only needs to add context. It does add account scoping and recency ('the account's recent'), but says nothing about ordering, how many runs are returned by default, or rate-limit/behavioral constraints.

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 one short fragment with no filler, but it is under-specified rather than genuinely concise — an incomplete noun phrase that omits the action verb and any routing context. Brevity here reflects a gap, not discipline.

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 should at least indicate what a 'run' record contains or how results are ordered; it does neither. For a list tool in a crowded deep_*/autopilot_* sibling set, the definition is too thin to call correctly without guessing.

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 'limit' parameter is fully documented in the schema (min 1, max 50, default 20). The description adds no syntax or semantics beyond what the schema already provides, so the baseline 3 applies.

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

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

The fragment 'The account's recent deep research runs' identifies the resource and the account-scoped, recency-limited view, but contains no verb and does not distinguish this from siblings like get_deep_analysis, get_deep_thread, or deep_events. It largely restates the title rather than sharpening the purpose.

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

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

No when-to-use guidance, no mention of alternatives such as get_deep_analysis for a single run or get_deep_thread for thread detail. The agent must infer that this is the discovery entry point for the other deep_* 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 declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds useful context that the response includes rates and 'typical points of a live call,' which partially compensates for the missing output schema, but it says nothing about scope, auth, or pagination.

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 short clause with no redundant phrasing, and the most distinctive qualifier ('can be set per agent') is front-loaded. It loses a point for being a sentence fragment rather than a complete statement of the tool's action.

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 does give an outline of the returned fields (models, rates, call points), which is the right instinct. However, phrases like 'typical points of a live call' are opaque, and no context is given about what a 'model' or 'agent' means in this domain, leaving the agent with an incomplete picture.

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

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

The tool takes zero parameters, and the schema is closed (additionalProperties false), so there is no parameter semantics to document. Baseline for a no-parameter tool applies at the top of the range.

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 is a noun phrase rather than a stated action, so the 'list' operation is only carried by the name/title. It does add scope ('models that can be set per agent') and hints at return content, but an agent must infer the verb. Sibling differentiation is weak — nothing explains how it relates to list_autopilots or run_autopilot_agent.

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

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

There is no statement of when to call this versus alternatives, and no preconditions or exclusions. Since it likely feeds configuration for agents, some routing guidance (e.g., 'use before update_autopilot to pick a model') would be valuable but is absent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context that annotations do not carry: the per-call cost of 0.2 points, which matters for a metered agent, plus a sketch of returned content (headline stats, event types).

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 clauses with no filler; the resource and its contents are front-loaded, and the cost caveat is parenthetically tucked away rather than dominating the text.

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

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

With no parameters, no nested objects, and no output schema, the description carries the burden of hinting at the return shape, and it does so briefly (headline stats, event types). A little more detail on the return fields would push this higher, but it is adequate for a zero-arg listing tool.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing parameter-related for the description to clarify, and it correctly avoids inventing arguments.

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

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

States a specific verb (list) and resource (sectors), and adds the scope of what is returned: 'under watch with headline stats and the event types they use.' This is distinguishable from the singular get_sector sibling, though the phrase 'under watch' is a bit opaque about which sectors qualify.

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

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

There is no when-to-use guidance and no mention of alternatives such as get_sector for a single sector or sectors_follows for subscription management. The cost note hints this is a metered call, but the agent is left to infer when to reach for it over the many sibling list/get 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — it does not explain what 'window' means (session state, trading hours, pre/post market) or what the caller gets back. With annotations carrying the burden, this is a bare pass but genuinely uninformative.

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 one short phrase, but this is under-specification rather than conciseness. A single sentence that names no verb, no output, and no scope has cut away information the agent needs, not 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 parameters and no output schema, the description is the only source of information about what this tool returns, and it supplies none. Even one clause about returning current market session state (open/closed/pre/post) would be necessary for an agent to call it correctly.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; baseline 4 applies. The description neither helps nor harms here.

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

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

Tautological: description restates name/title.

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 context, and no mention of alternatives. An agent cannot infer from this text under what circumstances market_status should be called versus get_sector_calendar or other market-related siblings.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is covered structurally. The description's only added behavioral fact is the cost ('1 point per call'), and that string is duplicated twice within a single sentence, adding noise rather than insight. Nothing is said about rate limits, failure modes, or whether the call is billable on partial input.

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 text is short but not concise in a useful sense: it repeats the tool title verbatim and states '(1 point per call)' twice in the same line. Every word is redundant with structured fields, so no 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?

There is no output schema, so the description should explain what comes back (translated titles, ordering, partial failures) and the expected language code format. Neither is present, and with no usage or return guidance an agent cannot confidently invoke this tool from the description alone.

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 two parameters ('titles' with '<= 20' and 'language' with 'Target language code') are already documented by the schema. The description adds no parameter semantics beyond the schema, but per the rubric a high-coverage schema establishes a 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?

The description does name a specific verb and resource ('Translate up to 20 titles'), so the basic action is identifiable. However, it is a verbatim restatement of the tool title, gives no differentiation from news-adjacent siblings like get_news or get_news_article, and never says what the titles are translated into or from.

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

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

There is no guidance on when to use this tool versus alternatives, nor any prerequisites such as whether a source language must be detected or a valid account/point balance is required. The only contextual note is a cost mention, which is 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 already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond it – no note on whether prices are live, cached, or versioned. With annotations carrying the burden, a neutral 3 is appropriate.

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 a single short fragment with no waste, but 'conciseness' achieved by duplicating the title is under-specification rather than efficiency. It is front-loaded but carries zero information payload.

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

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

For a global pricing endpoint there is no output schema, so the description is the only place an agent could learn what the payload contains (point values, plan tiers, limits). It supplies none of that, leaving the agent unable to predict the return shape or decide when this tool is the right call.

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 per the calibration baseline this dimension is a 4. There is nothing for the description to document and it does not pretend otherwise.

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?

Tautological: description restates name/title.

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, no when-not-to-use, and no mention of alternatives such as usage_get, list_models, or get_account, even though pricing data plausibly overlaps with usage. The agent is given no routing signal.

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's only behavioral claim is 'no execution', i.e. a side-effect-free quote, while the annotations declare readOnlyHint=false. That is a direct conflict about whether this tool has side effects. The rest of the behavioral profile (openWorldHint=true, idempotentHint=false) is carried entirely by annotations, and the description adds no context such as whether quoting consumes points or requires auth.

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?

Extremely short, but the brevity is under-specification rather than concision: the single fragment is verbatim the tool title and carries no front-loaded guidance about scope, inputs, or output. Nothing is wasted, but almost nothing is communicated.

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 five optional parameters, a nested object, zero required fields, and no output schema, the description should explain what a quote returns and how endpoint/tier/asset shape it. It supplies only 'points a call would cost, no execution', leaving the agent to guess the return shape and the meaning of the nested models map.

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 tier, asset, agents, models, and endpoint are already documented in the schema, including the nested agent->model_id object. The description adds nothing about any of them, 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?

Tautological: description restates name/title.

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 statement of when to use this versus pricing_get, usage_get, or the run/start execution siblings; the 'no execution' note only hints that it precedes an execution call. No prerequisites, no when-not-to-use, no named alternative.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false and destructiveHint=false, so the mutation profile is covered. The description adds genuinely new context beyond the annotations: the run consumes/meters points and the output is written to the event log rather than returned.

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 and short, but the cost point is stated twice: 'Uses points. (uses points, metered on the models used like the website)'. The parenthetical restates rather than adds, wasting the most valuable position in the description.

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

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

With no output schema, the description correctly tells the agent the result lands in the event log, and it flags the point cost. Since the required 'agent' enum is undocumented and no sibling alternative is named, it stops short of being sufficient for confident invocation.

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

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

Schema description coverage is 50% (autopilot_id documented, the agent enum is not), and the description adds no meaning to either parameter — it never explains the indicator/intelligence/fundamental/decision values. It only gestures at 'the models used', which is not tied to a named parameter.

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

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

States a specific verb and resource ('Run one of the autopilot's agents now, outside its schedule') and notes where the result goes. The 'outside its schedule' qualifier implicitly distinguishes it from start_autopilot, though it never names the sibling explicitly.

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

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

Gives an implied trigger ('now, outside its schedule'), which tells the agent this is an on-demand run rather than a scheduled one. It never states when to prefer start_autopilot or autopilot_action instead, leaving the routing decision to inference.

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

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

Beyond the annotations (readOnlyHint=false, openWorldHint=true, non-idempotent, non-destructive), the description discloses the async contract ('Returns a run id right away') and the cost model (points at website rates, metered on models used). It does not cover failure/cancellation behavior, but it adds substantial value over the annotation set.

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 and async/cost facts efficiently in a compact block, but the trailing parenthetical '(uses points, metered on the models used like the website)' duplicates the earlier 'Uses the account's points at the website's rates', which is minor waste.

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

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

With no output schema, the description correctly explains the async return (run id) and the follow-up retrieval tool, and covers cost and agent composition for a 7-parameter tool. It is complete enough to invoke correctly, lacking only edge-case behavior.

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 explaining the semantic role of the four agents (indicator, intelligence, fundamental, decision) and pointing to list_models for the model override field, adding meaning beyond the raw schema.

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

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

States a specific verb and resource ('Run SimianX's four live AI analysts once on a US stock or a crypto pair') and even enumerates the four agents and what each does. It also implicitly distinguishes itself from the sibling get_live_analysis by defining the run/poll split.

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

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

It gives clear context: run this 'once' and collect results with get_live_analysis, and it warns that the tool consumes account points. It does not explicitly exclude alternatives like start_deep_analysis or autopilot tools, so routing among those siblings 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 already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds only the searchable scope (US stocks, ETFs, crypto pairs) and match key (name or ticker); it says nothing about result ordering, ranking, or whether the limit truncates silently.

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

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

A single front-loaded sentence with no filler; the purpose and output intent arrive in the first clause and 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?

For a simple read-only lookup with three fully documented parameters and complete annotations, the description is nearly sufficient. It leaves the exact return shape (symbol/name pairing) and limit-truncation behavior unstated, a minor gap given there is no output schema.

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

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

Schema coverage is 100%, with the enum and limit bounds fully documented in the schema, so the baseline is 3. The description's 'name or ticker' and asset-type phrasing mirrors the schema without adding meaning beyond 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 gives a specific verb+resource: 'Find the symbol' across 'US stocks, ETFs and crypto pairs' matched by 'name or ticker'. This clearly distinguishes it from the quote/indicator siblings, which consume symbols rather than resolve them, so an agent knows exactly what this tool returns and why.

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?

'Find the symbol to use' implies the tool is a lookup step that feeds downstream quote tools, but the description never states when to call it versus alternatives or any exclusion. Usage is inferable rather than stated, which fits the 'implied usage' level.

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 and destructiveHint=false, so the safety profile is covered. The description's one extra behavioral fact is the cost — '0.3 points per call' — which is genuinely useful billing context and would otherwise be invisible; it stops there, saying nothing about return shape 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?

A single compact fragment that front-loads the resource and ends with the cost note; nothing is padded. It is a run-on list rather than a well-formed sentence, but it is efficient.

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

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

There is no output schema and no annotations gap, so the description partially compensates by listing returned sections. But it omits the routing information (json vs the plural siblings) and parameter sourcing that an agent needs to call it correctly, leaving it only minimally 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% with both params ('slug' = Asset slug, 'sector' = Sector slug) documented, so the baseline is 3. The description adds no meaning beyond the schema — it never explains the sector/slug relationship or how to obtain the slugs.

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

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

The description identifies the resource (a single asset) and enumerates its return contents (links, trials, readiness checklist, events, calendar, owning company), which helps distinguish it from the plural sibling sectors_assets. However, it never states an action verb — it's a noun fragment restating the title 'One asset' — so an agent must infer that this is a retrieval call.

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

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

No guidance on when to use this tool versus alternatives. The obvious candidate, sectors_assets, is not mentioned, nor is sectors_stock or sectors_event, and no preconditions (or required level of the sector/slug hierarchy) are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral fact the annotations do not: the call costs 0.3 points. It discloses nothing about pagination or result shape, so a 3 fits.

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 a single short fragment with the cost front-loaded, so nothing is padded. However, the phrase is essentially a title echo, meaning it is terse rather than efficient — brevity at the cost of substance.

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 6 parameters, no output schema, and a crowded sector-tool namespace (sectors_asset, sectors_stock, sectors_stocks, sectors_event, sectors_follow), the description supplies no filtering, paging, or disambiguation context. Annotations cover safety, but the definition leaves an agent unable to confidently place this tool among its siblings.

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 83%, so the schema already documents most parameters (q, limit, stock, offset, sector). The description adds only that results are drugs/products-style assets, which is marginal. Baseline 3 is appropriate when the 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?

The description is a bare noun phrase that essentially restates the title 'Tracked assets (drugs, products) of a sector' with no verb (list/fetch). It does not distinguish this tool from close siblings such as sectors_asset, sectors_stock, sectors_stocks, or sectors_event, so an agent cannot tell why the plural 'assets' tool differs from the singular one.

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, when-not-to-use, or alternative-tool guidance anywhere in the text. Given five similarly-named sibling sector tools, the omission 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 declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description's one genuine addition is the per-call point cost (0.2), which is real economic context not present in annotations. It still says nothing about pagination, result size, or error behavior for bad slugs.

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 with the payload inventory front-loaded and the cost appended last. It is efficiently sized, though the wording is a near-verbatim copy of the title, which costs it a point for 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?

With no output schema, the description earns credit for enumerating the returned sections (summary, facts, calendar item, readiness, related events), which is what an agent needs most here. However, for a two-parameter lookup tool it gives no routing guidance relative to the many sibling event tools, leaving selection ambiguous.

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 both required parameters (sector, slug) are documented in the schema, including the note that slug accepts a permalink slug or event id. The description adds no further meaning, so the baseline 3 for fully-covered 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?

The description names the resource and enumerates its payload parts (summary, facts, calendar item, readiness) plus related events, so an agent knows roughly what comes back. But there is no operative verb and no differentiation from close siblings like get_sector_events or get_pulse_events, which fetch overlapping data. Purpose is discernible but not sharp.

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 prerequisites, and no naming of alternatives such as get_sector_events (list) or get_sector_calendar. The only indirect signal is the '0.2 points per call' cost, which hints at preferring cheaper bulk endpoints but never says so 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 declare readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the description is not carrying the whole burden, yet it still adds meaningful side-effect disclosure: the first follow in a sector creates an email subscription, and a plan tier is required. This goes beyond what the annotations state, though it doesn't clarify behavior on repeat follows or whether an existing subscription is modified.

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 – essentially one sentence with two parentheticals, no filler. The side-effect and plan conditions are packed in, though the two stacked parentheses make it slightly dense to parse.

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

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

For a 7-parameter write tool with full schema coverage, no output schema and non-destructive annotations, the description covers the key behavioral facts (side effect, tier requirement). Minor gaps remain on repeated-follow behavior and per-type parameter usage, but nothing critical blocks correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters (id, slug, type, sector, ticker, timezone, reminder_offsets) including which type each applies to. The description adds no syntax, format, or selection guidance beyond what the schema provides, 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 (Follow) plus the three resource kinds it accepts (stock, asset, calendar item), so an agent can distinguish it from siblings like sectors_unfollow and sectors_follows. The parenthetical about the sector email subscription adds scope context but the phrasing is somewhat cramped.

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

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

Provides a real prerequisite ('needs the starter plan or above') that gates usage, which is useful. However, it offers no explicit when-to-use versus when-to-unfollow or when to prefer a listing tool; the distinction from sectors_unfollow/sectors_follows is only inferable from the names.

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 and destructiveHint=false, so the safety profile is covered. The description adds an entitlement constraint (starter plan or above) that the annotations do not convey, which is useful. It says nothing about the return shape or whether results are paginated.

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 short sentence with the entitlement constraint placed in a clear parenthetical, no padding or repetition. It is efficient, though the content itself is thin rather than rich.

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, single-parameter, idempotent tool with annotations covering safety and no output schema, the definition is barely adequate. It communicates the entitlement requirement but leaves the return content ('follows ... and its subscription') only gestured at and offers no sibling differentiation, which is the main gap.

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

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

Schema coverage is 100% and the single parameter 'sector' is documented as 'Sector slug'. The description adds no format, example, or meaning beyond that, so the baseline of 3 for fully documented parameters applies.

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

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

The description is a verbatim restatement of the title with a parenthetical added, so it duplicates information the agent already has from the name/title field rather than stating what the tool does with a verb+resource. It never clarifies how it differs from the closely named siblings sectors_follow and sectors_unfollow, which is exactly the distinction an agent needs. It reads as a noun-phrase label, not a purpose statement.

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 supplies a genuine prerequisite ('needs the starter plan or above'), which is actionable usage context. However, it offers no when-to-use guidance relative to alternatives such as sectors_follow (follow a sector) or sectors_unfollow, leaving the routing decision to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds two things the annotations do not: the per-call credit cost (0.3 points) and the fixed 90-day lookback window on the calendar, both of which affect invocation decisions. It omits any note on rate limits or why a 'point' cost applies.

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 clause, front-loaded with the resource identity followed by the returned components and the cost in parentheses. Nothing is repeated and 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 reasonably carries the burden of listing returned components, and it does so. But it leaves two gaps that matter for a tool in this dense a sibling set: how 'sectors_stock' differs from the plural 'sectors_stocks', and what 'tracked assets' means concretely. Adequate but incomplete.

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

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

Schema description coverage is 100% and both parameters ('sector' slug, 'ticker') are documented in the schema itself, so the baseline of 3 applies. The description adds no format details — e.g. whether the sector slug must come from list_sectors, or whether the ticker is exchange-qualified.

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

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

The description names the resource precisely — a single company within a sector — and enumerates what the call returns (profile, tracked assets, calendar, events, market-cap peers). That is enough to separate it from get_sector (whole sector) and sectors_assets. It stops short of an explicit verb, so it reads more like a content manifest than a purpose statement.

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

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

There is no when-to-use guidance and no named alternative, which matters because the sibling list contains sectors_stocks, sectors_asset, sectors_assets, and sectors_event — names close enough that an agent has no stated basis for choosing this one. The '0.3 points per call' note implicitly tells the agent this is not free, but never says when to prefer a cheaper sibling.

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, and destructiveHint=false, so the safety profile is covered. The description adds only the cost per call, which is useful but thin behavioral context beyond the annotations.

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

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

The description is very short and front-loads the purpose, with the cost in parentheses. It avoids any filler, though it is a fragment rather than a structured 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 simple read-only list endpoint with full parameter descriptions and safety annotations, the description covers the core purpose. However, it omits any routing guidance among many sector-related siblings, leaving a meaningful gap.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema. The description does not add syntax, format, or enum details beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description states the specific resource and scope: constituent stocks of a sector. It is clear what the tool returns, but it does not distinguish itself from siblings such as sectors_stock, sectors_assets, list_sectors, or get_sector.

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

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

There is no guidance on when to use this tool versus alternatives. It also does not mention prerequisites, required permissions, or selection conditions, though the cost per call is noted.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and absence of readOnly, so the safety profile is covered structurally. The description adds the entitlement prerequisite (starter plan or above), which is behavioral context the annotations do not carry and which directly affects whether the call is permitted.

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

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

A single front-loaded sentence with the action first and the qualifiers in parentheses. Slightly cluttered by stacked parentheticals, and the title is visibly truncated ('(stock'), but the body wastes no words.

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

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

For a two-parameter mutation with rich annotations and no output schema, the description covers the action, the key formats, and the plan prerequisite. The only thin spot is that the required 'sector' scoping 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 coverage is 100%, so the baseline is 3, but the description goes beyond the schema by giving concrete target-key formats (stock:SMMT, asset:<slug>, calendar:<id>), which materially clarifies what the 'id' parameter accepts.

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

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

The description states a specific verb ('Remove') and resource ('a follow'), and specifies the two lookup modes (by id or by target key). It is easy to distinguish from the sibling sectors_follow, though it never names that counterpart 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?

It supplies a real prerequisite ('needs the starter plan or above'), which is useful context for whether the call can succeed. However, it gives no explicit when-to-use-vs-alternative guidance against sectors_follow or any other sibling, so usage is only implied.

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

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

Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=true), so the bar is lower. The description adds genuinely useful non-schema behavior: submissions are human-read and explicitly not answered, setting correct response expectations. It could still say more about rate limits or confirmation behavior.

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

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

Two economical sentences with zero filler, and the core action is front-loaded before the expectation-setting clause. Every phrase 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?

It handles the response expectation well ('not answered') which matters for a one-way submission tool with no output schema, but with four parameters and 25% schema coverage it leaves the agent under-informed about message, category, and severity, which are the fields the agent must actually populate.

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 25% – just request_id is documented. The description vaguely echoes the category enum ('bug, missing data, idea') but says nothing about the required message field, the severity levels, or how request_id links a report to a call, so it fails to compensate for the coverage gap.

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

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

States a specific verb and recipient ('Tell the SimianX team') plus the kinds of submissions (bug, missing data, idea), which is enough to separate it from the sibling feedback_list that reads feedback rather than sending it. It stops short of explicitly naming that sibling, so it's clear but not fully differentiated.

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 enumerated cases ('a bug, missing data or an idea'), so an agent can infer when to call it. However, it gives no explicit when-not guidance and never routes the agent to feedback_list for reading existing reports.

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 and destructiveHint=false, so the safety profile is fully covered. The description adds only the timing guidance ('start of a session') and says nothing about whether the content is cached, versioned per skill, or how deprecations are surfaced.

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

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

A single, tight phrase with zero filler that front-loads the payload contents. It is appropriately sized for a no-argument informational tool, though it is essentially the title repeated rather than a distilled 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 tool with no output schema, the description adequately conveys what comes back (versions, changelog, deprecations) and when to call it. The lack of detail on return shape is acceptable given annotations carry the safety profile, though an output schema would have made it fully self-sufficient.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify and the baseline is 4. Schema coverage is 100% with no arguments to document.

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?

Tautological: description restates name/title.

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?

'Read at the start of a session' gives a clear, actionable trigger for when to call the tool. There is no explicit when-not or alternative named, but for a unique, no-argument metadata tool no alternative exists to route away from.

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 cover the safety profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=true), and the description adds genuinely new context: the tool consumes points on every cycle and is metered on the models used. That cost/metering behavior is not derivable from the annotations. It still omits what happens on failure or if the autopilot is already running.

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

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

The opening sentence is front-loaded and efficient, but the trailing parenthetical "(uses points, metered on the models used like the website)" largely restates the preceding "Uses points on every cycle" in looser wording rather than adding a new 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 tool with full annotation coverage and no output schema, the description covers the precondition and the cost side, which is adequate. It leaves gaps around error behavior (e.g., already-running autopilot) and what a successful restart returns.

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

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

Schema description coverage is 100% and the single parameter is documented as "Autopilot id", so the schema carries the full burden. The description adds no format, source, or lookup guidance for autopilot_id, making 3 the correct baseline.

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

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

States a specific verb (restart) and resource (autopilot), plus the precondition that the autopilot must be stopped. It distinguishes itself from stop_autopilot by implication but never names a sibling, so the differentiation is only partial.

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

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

"Restart a stopped autopilot" implies the tool is only valid for a stopped autopilot, which is a useful usage condition. However, it gives no guidance about related siblings such as autopilot_action or run_autopilot_agent, or what to do if the autopilot is already running.

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 readOnlyHint=false, idempotentHint=false and openWorldHint=true; the description goes beyond them by disclosing latency ('takes several minutes') and that the call consumes account points at website rates, which matters for a metered operation. It does not restate the non-idempotent/mutation nature of the call or whether repeated calls spawn parallel committees.

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

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

The core content is front-loaded and dense with useful detail, but the trailing parenthetical '(uses points, metered on the models used like the website)' duplicates the earlier 'Uses the account's points at the website's rates', leaving a redundant 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 long-running, metered job with no output schema, the description covers the key agent-facing facts: what it produces, how long it takes, how to retrieve results, and that it costs points. It stops short of describing failure/retry behavior or how to monitor progress via the sibling list_deep_analyses.

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

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

Schema coverage is 100% with enums and per-parameter descriptions for tier, asset, agents, models, horizon and language, so the schema carries the semantics. The description adds only asset-type context (stocks vs crypto committee composition, model overrides) and nothing about tier, horizon or language beyond the schema, so baseline 3 applies.

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

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

Names a specific verb and resource (start the deep research committee on a stock or coin) and spells out the committee seats and the deliverable (verdict with entry, stop and target). An agent can distinguish this immediately from sibling get_deep_analysis, which is explicitly named as the follow-up reader.

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: it is a multi-minute operation and should be followed with get_deep_analysis, which routes the agent correctly within the async pair. However it offers no guidance on when to prefer this over run_live_analysis, start_autopilot, or ask_deep_analysis, so the alternatives are left implicit.

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=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, covering the safety profile. The description adds only a restatement of the name plus a thin 'schedule' scope hint; it says nothing about what happens to the autopilot or its positions after stopping, or whether it can be restarted.

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 short sentence, front-loaded with the action, no filler or redundancy. It is efficient, though arguably terse enough that the scope of 'schedule' is left slightly ambiguous.

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 mutation tool with annotations carrying the safety profile and no output schema, the description is minimally adequate. It still omits any indication of side effects (e.g., whether an in-flight run is interrupted) that would complete the picture.

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?

Single required parameter with 100% schema description coverage, so the schema already documents autopilot_id fully. The description adds no format or identity detail beyond what the schema provides, which is the baseline expectation at full coverage.

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

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

States a specific verb ('stop') and resource ('an autopilot's schedule'), and the word 'schedule' subtly scopes the action as distinct from deleting the autopilot (autopilots_delete). However, it never explicitly names or contrasts with the obvious sibling alternatives, so an agent must infer the boundary itself.

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 prerequisite conditions, and no mention of alternatives such as autopilots_delete or autopilot_action. Usage can only be inferred from the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is known. The description meaningfully adds to this by disclosing that changing the timeframe or turning AI control off closes the paper position first — a concrete, non-obvious side effect not derivable from the annotations. It stops short of describing auth requirements or other partial-update effects.

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

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

Two short sentences, front-loaded with the enumeration of changeable fields, then the critical side-effect warning. Nothing is redundant or padded.

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

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

For an 8-parameter destructive mutation with nested objects and no output schema, the description covers the main fields and one important side effect, but omits guidance on the undocumented 'intervals' parameter, partial-update semantics, and confirmation/rollback behavior. Adequate but with clear gaps given the tool's complexity.

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 63% and the description mainly restates the field list already present in the schema (models, language, timing_gate, ai_position_control). Its added value is tying 'timeframe' and 'ai_position_control' to a destructive consequence, but it leaves 'intervals' (no schema description) and the nested 'models' override semantics unexplained.

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

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

States a clear verb ('change') and enumerates the mutable fields (models, intervals, language, timing gate, AI position control), so the agent knows precisely what this tool mutates. It does not explicitly differentiate itself from siblings like create_autopilot or autopilot_action, but the resource and effect are 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?

There is no guidance on when to reach for this tool versus create_autopilot, autopilot_action, stop_autopilot, or get_autopilot. The second sentence hints at a usage consequence (position closure) but frames it as behavior, not as a when-to-use/when-to-avoid condition.

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 and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing further — no note on what 'usage' aggregates, whether it is per-endpoint or per-day, or how the open-world lookup behaves — so it contributes no behavioral context of its own.

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 single phrase is short but this is under-specification rather than conciseness — an effectively empty description cannot be considered well-structured or front-loaded when it conveys no actionable content.

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

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

For a tool with two optional filters and no output schema, the agent still does not know what the response contains (counts, tokens, per-endpoint breakdown) or how the result is shaped. The description leaves the core question of what 'usage' means unanswered.

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%: 'days' (1-31, default 7) and 'key_id' (only this key) are fully documented in the schema. The description adds no syntax or meaning beyond that, which is the baseline 3 when the 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?

Tautological: description restates name/title.

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 mention of alternatives among the ~50 sibling tools (e.g. pricing_get, get_account), and no stated prerequisites or context for choosing this tool.

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