mcp-server

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only defines what a custom signal is. It says nothing about creation semantics such as compile_failed validation, naming conflicts, or how expressions are echoed back; those details live only in parameter descriptions, not the tool description.

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

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

The description is a single sentence with no filler: it defines the entity and its intended usage in one pass. Information is front-loaded and every word contributes.

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 one-line definition plus detailed schema properties and an output schema is adequate for an agent to attempt a call, but the tool description alone does not state the create action, error behavior, or permissions. Given the tool has no annotations, some important operational context is missing from the description itself.

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 thoroughly documents expr, name, and description. The top-level description adds no parameter-level meaning beyond pointing out that a custom signal can be referenced wherever built-in signals are used, leaving the schema to carry semantic weight.

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

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

The description clearly identifies the created entity as a 'named boolean predicate' and explains its reuse 'anywhere a built-in signal goes,' so an agent can tell it apart from plain scan expressions. It stops short of using an explicit performative verb like 'creates,' relying on the tool name to convey the create 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?

The phrase 'reference anywhere a built-in signal goes' implies the main use case: define a custom signal once and reuse it. It does not explicitly say when to choose this over inline expressions, update/delete operations, or the sibling create_universe/create_webhook tools, so guidance is mostly 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?

No annotations are provided, so the description carries the full behavioral burden. It only states that a list is created and owned by the account; it does not disclose id generation, slug validation, reserved names, ticker validation, empty-list acceptance, persistence behavior, or error semantics. Those details appear in the schema, not in the tool description.

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

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

The description is a single concise sentence with the verb and direct object front-loaded and no filler. 'Owned by your account' adds relevant context without bloat. Every word earns its place.

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

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

The tool is a straightforward create operation and the input schema richly covers parameters and output schema exists, so the agent can construct a valid call. However, the description itself provides no usage guidance or behavioral context and there are no annotations, leaving some selection and expectation-setting gaps that a fuller description would 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 100%; each of the four parameters is individually documented with constraints like the id pattern, reserved values, length limits, and ticker validation. The tool description adds no parameter-level meaning, but the baseline 3 is appropriate because the schema already 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 names a specific action ('Create') and resource ('named ticker list') and clarifies ownership ('owned by your account'). This distinguishes it from sibling create tools like tickerbot_create_custom_signal and tickerbot_create_webhook, and from update/delete universe tools.

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

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

There is no explicit when-to-use guidance, no mention of alternatives, and no exclusions such as 'use update_universe for modifications.' The only usage signal is the verb 'Create' and the tool name, so the agent must infer when this tool should be selected.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it steps up: it discloses the paid-plan gating (a real behavioral constraint), the canonical-vs-sugar relationship, and how the discriminated trigger selects its shape. It doesn't mention idempotency or failure behavior, but for a create operation with an output schema present, the key disclosures (plan gate, trigger discrimination) are genuinely additive.

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

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

Three dense sentences with zero waste. Purpose is front-loaded ('Canonical create'), the trigger taxonomy is packed into one sentence, and the sibling-relationship and plan constraints get their own crisp clauses. Every sentence earns its place — this is model concision, not 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 10-parameter tool with a nested discriminated union and an output schema, the description covers the conceptual frame, the trigger shapes, the sibling routing, and the plan gate. The output schema covers return values, so the description doesn't need to. Missing minor items like rate limits, but the combination of description plus schema plus output schema is largely sufficient for an agent to call this correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real value beyond the schema: it explains the 'trigger plus delivery' mental model, summarizes each trigger shape's fields (scan/ticker/signal/event), and clarifies how the discriminated object maps to the flat subscribe shortcuts. This conceptual glue is exactly what the raw schema lacks, especially for the nested trigger object.

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 ('Canonical create') and defines the core concept ('a webhook is a trigger plus a delivery'). It names sibling subscribe tools and asserts they are 'flat sugar over exactly this', clearly differentiating this canonical tool from those flat variants. The trigger-shape taxonomy is laid out compactly, leaving no ambiguity about what the tool does.

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

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

Explicitly routes between the canonical create and the subscribe sugar: 'The subscribe tools are flat sugar over exactly this' tells an agent when to prefer which. It also discloses the paid-plan requirement ('Webhooks need a paid plan (Free has no webhook slots)'). It could be slightly more explicit about when-not-to-use, but the subscribe relationship plus plan gating covers the main decisions.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It explicitly discloses that deletion is refused by default when another signal references it, and that using force will break those references on recompile. This is valuable destructive-behavior context, though it does not additionally state whether deletion is irreversible or what permissions are required.

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

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

The description is two short sentences with no filler. The core operation is front-loaded, and the most important caveat about reference checks follows immediately. Every word earns its place.

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

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

For a two-parameter tool with a fully documented schema and no nested objects, the description is nearly complete. It explains the default behavior and the force escape hatch. The only minor gaps are the absence of any mention of output/response shape and explicit irreversibility, but those are not critical for invoking the tool correctly.

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

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

The schema already documents both parameters with 100% coverage, so the baseline is 3. The description adds semantic value by explaining the default refusal consequence, which gives real meaning to the force parameter and the reference-check behavior. The signal parameter details are already well covered in the schema.

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

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

The description uses a specific verb and resource: 'Delete one of your custom signals.' This clearly separates it from sibling tools like delete_universe and delete_webhook, and the operation is obviously distinct from create/update custom signal tools. The first sentence leaves no ambiguity about what the tool does.

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

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

The description implies when to use the tool: when a custom signal needs to be removed. However, it does not explicitly name alternatives or state when not to use it, such as when the signal is a built-in or when the user should choose update instead. The usage guidance is adequate but left mostly 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?

With no annotations, the description carries the safety burden; it satisfies this by calling out permanence and the downstream effect on referencing webhooks. It also implies that deletion is not just a soft remove, since webhooks begin failing on eval. This exceeds a simple 'deletes a universe' statement.

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

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

Two compact sentences with no filler. The action is front-loaded and the important warning is in the second sentence, making the most relevant information immediately visible.

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

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

The description covers the dangerous consequences (permanent deletion and dangling webhooks), and the schema covers id and force behavior. There's no output schema, but for a delete operation the missing return details are less critical; still, no annotation means minor details like ownership/permissions are only implied by 'your universes'.

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

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

The schema already describes both parameters at 100% coverage, so the description gets the baseline 3. The only slight added context is 'your universes' for ownership, but it adds nothing about the id slug or force flag that isn't already in the schema.

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

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

The description opens with a specific verb and object — 'Permanently delete one of your universes' — and uses 'permanently' to make the irreversibility explicit. It clearly differentiates from sibling tools like create_universe, update_universe, and get_universe.

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

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

It states the core use case ('delete one of your universes') and provides a concrete precondition: clean up referencing webhooks first, because they 'fail on their next eval.' It doesn't name alternatives or explicit when-not-to-use conditions, but the caution gives clear context for deciding whether to proceed.

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

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

With no annotations provided, the description carries the full behavioral burden for a destructive operation. It explicitly discloses that delivery history is also deleted, which is the most important side effect. It omits other details like idempotency or error behavior, but the key destructive consequence is transparent.

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

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

One sentence, front-loaded with the action and immediately followed by the critical side effect. There is no filler or redundancy, making it highly efficient.

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

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

For a one-parameter destructive operation with no output schema, the description plus schema give an agent enough to call it correctly: the resource, the id, and the collateral deletion. Minor gaps like nonexistent-id handling and prerequisites prevent a perfect score, but the tool is simple enough that the description is nearly complete.

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

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

Schema description coverage is 100%: the single 'id' parameter is documented with 'Webhook id.' The tool description adds no additional parameter semantics, so the baseline score of 3 applies since the schema already covers the 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?

The description states a specific action and resource: 'Delete a webhook subscription'. It also reveals the collateral consequence ('and its delivery history with it'), which clearly distinguishes it from sibling deletes for other resources like tickerbot_delete_custom_signal and tickerbot_delete_universe.

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

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

The description provides no guidance on when to use this tool versus alternatives such as tickerbot_update_webhook or tickerbot_enable_webhook. It does not mention prerequisites, error conditions, or scenarios where deletion should be avoided.

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

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

With no annotations provided, the description carries the full disclosure burden. It openly reveals the non-obvious side effect that match-state is cleared, so the next eval treats matching tickers as new. It stops short of describing behavior for already-enabled webhooks or error cases, but the core destructive side effect is transparent.

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

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

Two sentences, both information-denseched. The primary action is stated first Ia and the important side effect follows immediately. No filler or repetition 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 single-parameter tool with an output schema, the description covers the action and the critical state-reset behavior. It could clarify behavior if the webhook is not currently disabled, but the provided information is otherwise sufficient for an agent to invoke it correctly.

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

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

The schema already fully documents the only parameter, 'id', as the webhook id. The description adds no extra semantic detail about the id beyond that, so it does not meaningfully increase parameter understanding.

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

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

The description uses a specific verb and resource: 'Re-enable a disabled webhook and start it clean.' This clearly distinguishes it from create/delete/test/update webhook operations, and the state-changing intent is explicit.

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

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

The description gives clear context for when to use this tool: when re-enabling a disabled webhook. It does not explicitly name alternative tools or state when not to use it, but the use case is unambiguous from the operation described.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. The description only states what the tool returns and does not mention any behavioral traits such as side effects, authentication requirements, rate limits, or response format. This is a significant gap for a data retrieval tool.

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

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

The description is extremely short, but it is under-specified rather than concise. It lacks structure and meaningful content, with a cryptic phrase that does not aid understanding. It is not front-loaded with useful information and reads as an incomplete thought.

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 10 parameters and a rich schema, the description is severely inadequate. It does not explain when to use the tool, what to expect in the response, or any operational constraints. The output schema exists but the description does not reference or complement it. This fails to provide the context an agent needs.

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 parameters comprehensively. The description adds little beyond noting interval availability, which is already in the schema. Per the baseline rule for high coverage, a 3 is appropriate since the description does not need to compensate but also provides minimal added value.

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

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

The description states the tool returns OHLCV bars across various intervals, which gives a general sense of purpose. However, it lacks specificity about the resource scope and does not differentiate it from siblings like get_series or get_ticker. The phrase 'the prices underneath the table' is vague and doesn't add clarity.

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 use this tool versus alternatives. There is no mention of conditions, exclusions, or when a different tool would be more appropriate. Given the large set of sibling tools, this is a critical omission.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses important edge-case behavior: non-ETF tickers return is_etf=false with empty holdings, and is_etf=true with zero holdings means data not yet ingested. It does not explicitly discuss rate limits or mutation, but 'Returns' and the get_ prefix imply a read-only operation, and the edge cases are well covered.

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

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

The description is concise and well-structured: it leads with the core purpose, then explains edge cases, then gives an explicit exclusion. Every sentence adds value and there is no redundant repetition of schema information.

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

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

Given the rich output schema and highly detailed limit parameter description, the tool description covers the main behavior, edge cases, and an important alternative. It is complete enough for an agent to select and invoke the tool correctly without additional 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 baseline is 3. The description adds meaningful parameter-level semantics beyond the schema by explaining what happens when the ticker is not an ETF and clarifying the distinction between empty holdings and not-ingested holdings. This goes beyond the schema's simple 'ETF symbol' description.

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

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

The description uses a specific verb and resource—'Returns an ETF's constituents and their weights'—and immediately distinguishes the tool from reverse lookup by stating that 'which ETFs hold NVDA' is not this tool. It also clearly differentiates from sibling tools like get_etf_sectors by focusing on constituents and weights.

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

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

The description explicitly states when to use this tool (for ETF holdings) and when not to use it (reverse lookup should be a scan filter on etf_holders). It also covers edge cases like non-ETF tickers, which helps an agent decide when this tool is appropriate.

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

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

With no annotations, the description fully discloses key behaviors: it guarantees completeness, specifies ordering, and handles non-ETF tickers by returning is_etf=false and empty sectors. This goes beyond the schema and provides essential edge-case context.

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

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

The description is three short sentences, front-loaded with the main purpose, and includes only necessary behavioral details. No fluff or redundancy.

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

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

For a simple read tool with a single parameter and an existing output schema, the description covers return content, ordering, completeness, and edge-case behavior. Nothing essential is missing for an agent to invoke it correctly.

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

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

The schema already describes the ticker parameter as an ETF symbol and case-insensitive, so the description adds no additional parameter semantics. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: returns an ETF's sector weights, ordered heaviest first. It also distinguishes itself from the sibling tickerbot_get_etf_holdings by focusing on sectors rather than holdings.

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 – an agent would infer to use this when needing sector weight data for an ETF. However, the description does not explicitly mention when not to use it or suggest alternative tools like tickerbot_get_etf_holdings, leaving the selection somewhat to inference.

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

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

With no annotations, the description carries the burden. It discloses cursor-paged backward behavior and transitions_only semantics, which are useful. However, it does not explicitly state read-only nature, error handling, rate limits, or other behavioral traits beyond the core retrieval and paging. It covers key behaviors but leaves some gaps.

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

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

The description is three concise sentences, front-loading the core capability and then adding the paging and transitions nuance. Every sentence contributes value without redundancy, and it is well-structured for quick comprehension.

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

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

The description gives a strong executive summary of the tool's purpose and key behaviors, while the extensive schema descriptions cover all 10 parameters. The output schema exists to define returns. Some nuances like asof semantics are left to the schema, but the description is complete enough as an overview for a complex 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%, so each parameter is fully documented in the schema. The description itself adds no parameter-level detail beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description states a specific resource (signals for tickers) and a distinctive capability: retrieving any signals for any tickers on a shared time grid, with paging and transitions. This clearly differentiates it from siblings like get_bars (likely single-ticker) by emphasizing multi-ticker alignment and cross-sectional behavior.

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

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

The description implies a multi-ticker signal use case but does not explicitly contrast with alternatives or state when to use this tool versus others. It does not mention 'for single-ticker history, use get_bars' or any exclusion criteria, leaving the when-to-use inference to the agent.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: condition requirements for non-boolean signals, sorting by signal value desc for non-booleans, and the asof historical option. It does not mention errors, pagination, or live-only constraints, but those are covered in the schema. It adds value beyond the schema by summarizing condition syntax.

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

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

The description is three sentences with no filler. It front-loads the purpose, includes concrete examples, and states the sort behavior. Every sentence earns its place, making it efficient and scannable.

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

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

Given the complexity (9 parameters) and the rich input schema, the description provides sufficient context for an agent to understand the tool's core function. It does not cover all edge cases (e.g., live-only restrictions on sort_by and interval), but those are explicitly documented in the parameter descriptions. The output schema further reduces ambiguity. The description is complete enough when combined with 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?

The description adds meaning beyond the input schema by providing a quick summary of condition types and sorting rules. While the schema has detailed per-parameter descriptions (100% coverage), the description condenses the essential logic into a few examples, making it easier for an agent to grasp the condition parameter without reading the full schema.

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

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

The description clearly states that the tool returns the set of tickers matching a signal, either currently or as of a past moment. It uses a specific verb ('get') and resource ('signal'), and the phrase 'One name, the whole market, one call' conveys scope. It distinguishes itself from siblings like get_bars and get_series by focusing on signal state.

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

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

The description implies usage (for retrieving tickers matching a signal) but does not explicitly compare to alternatives or state when not to use it. It does not mention sibling tools like scan or subscribe_signal, so an agent must infer appropriateness. The guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the behavioral disclosure burden and does it well: it explains live vs. asof reads, batch result keying, the not_found field, and the crypto prefix distinction. It does not discuss rate limits or failure modes, but it covers the most important behavioral traits.

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

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

Two dense sentences deliver the core behavior, batch capability, historical mode, and ticker-prefix caveat without filler. Key information is front-loaded.

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

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

The tool is relatively complex, but the description covers the essential calling contexts: single vs. batch, live vs. asof, and the crypto/ETF distinction. With a full input schema and output schema present, the remaining parameter and return details are adequately covered.

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

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

The input schema already documents all parameters at 100% coverage, including the asof format, interval constraints, and ticker naming conventions. The description adds a small amount of value by mentioning the batch response shape, but mostly restates what the schema already provides.

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

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

The description names a specific operation and resource: return the full ticker row with every signal for one symbol or a batch of up to 50. It is clear and specific, but it does not explicitly differentiate itself from sibling tools such as get_signal or get_bars.

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

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

The description implies when to use this tool, especially for getting the full current or historical ticker snapshot and for batch symbol lookups. However, it never explicitly contrasts this with alternatives or states when another sibling tool should be preferred.

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

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

With no annotations, the description carries the full burden, and it delivers: it explains that an empty result is meaningful, not ambiguous, and that `minute_tier.included: false` with `on_demand: true` is expected behavior because sub-hour bars fetch on first request. This prevents a caller from misreading the response.

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

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

Three short sentences, with the primary purpose front-loaded and no filler. The conditional example earns its place by resolving a likely misreading.

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

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

For a single-parameter query with an output schema, the description covers what the tool returns, when to call it, and a non-obvious output field interaction. Nothing essential for invoking it correctly is missing.

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

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

Schema coverage is 100%, and the ticker schema description is rich (case-insensitivity, prefix conventions, bare BTC/ETH are ETFs). The main description adds no additional parameter semantics, so the baseline 3 is appropriate.

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

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

Opens with 'For one ticker, what we hold and how far back,' which names the resource (one ticker's coverage) and the specific output (coverage depth/history). The empty-result clarification distinguishes it from data-retrieval siblings like get_bars/get_series, so an agent can route correctly.

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 instructs: 'Ask this before treating a gap in bars or series as an outage,' a concrete when-to-use condition. It doesn't name the sibling tools to avoid, but the reference to bars/series is sufficient context.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Returns the universe doc' implies a read-only operation and the ownership constraint is stated, but failure behavior (e.g., what happens for a nonexistent or unauthorized slug), permissions, or side effects are not covered. This is minimally adequate for a simple GET-like tool.

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

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

Two short sentences with no wasted words. The main action ('Returns the universe doc') is front-loaded, and the slug ownership constraint immediately follows. Every sentence earns its place.

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

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

An output schema exists, so return values are already specified. The description covers the key operational constraint (slug ownership) and the special-case system universes. It could mention using tickerbot_list_universes to discover owned slugs, but that is more of a usage alternative than a missing requirement for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining that top_10/top_100 are special system slugs and that other slugs must be owned by the account, which goes beyond the schema's bare 'Universe slug' description and helps the agent choose valid inputs.

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

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

The description states a specific verb ('Returns') and resource ('the universe doc'), and clarifies the two categories of valid slugs (system universes like top_10/top_100 vs. account-owned). This distinguishes the tool from sibling list/create/delete universe tools and gives the agent a clear idea of what to expect.

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

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

The description gives concrete guidance on acceptable slug values (system universes vs. account-owned) and implies that only owned slugs are fetchable. However, it does not explicitly name alternative tools (e.g., tickerbot_list_universes for enumeration or tickerbot_create_universe for creating), so the guidance stops short of explicit when/not-alternatives routing.

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

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

No annotations are provided, so the description carries the full burden. 'Current state' hints that the operation is read-only, but it does not explicitly state that it makes no modifications, does not require special permissions, or can fail if the webhook does not exist. Error behavior, rate limits, and side effects are entirely undisclosed.

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

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

The description is a single, short, front-loaded sentence with no filler or redundancy. It is structurally concise, though it sacrifices valuable content like a verb and usage context. Given its brevity and lack of waste, a 4 is appropriate.

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

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

For a one-parameter getter with an output schema, the description is still incomplete. It omits usage guidance and explicit read-only behavior, and does not explain how this tool fits with related tools. Even with the schema covering parameters and returns, the description fails to provide enough context for an agent to decide when 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 lone parameter 'id' is fully described in the input schema, which already explains that it comes from a subscribe endpoint. With 100% schema description coverage, the description does not need to add parameter details; it only vaguely refers to 'one webhook' without adding meaning beyond the schema.

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

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

The description identifies the resource (webhook subscription) and singular scope, which helps distinguish it from list_webhooks, but it is phrased as a noun phrase ('The current state...') rather than an action verb like 'Retrieves' or 'Gets'. The intended operation is only implied by the tool name, making the purpose somewhat vague.

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 its siblings. It does not mention that it fetches a single webhook by ID, nor does it recommend alternatives like list_webhooks for multiple webhooks. The description gives no contextual signal to help an agent choose this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses several important behaviors: case-sensitivity rules ('`firm`/`action` match case-insensitively; a `q` payload match is case-sensitive'), the `join: state` behavior ('attaches the ticker state as of each event'), and the interval resolution behavior ('`auto` resolves to `1d`... events on tickers absent from that tier join to `null`'). It also discloses error conditions (400 for firm without kind=analyst, 400 for signal without kind=signal). This is substantial behavioral context beyond what the schema provides.

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

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

The description is compact for a tool with 20 parameters. It front-loads the core purpose in the first sentence, then states the critical bound requirement, then adds the case-sensitivity and join behavior. Every sentence adds value. It could be slightly more structured (e.g., separating the bound requirement into its own paragraph), but it's efficient and well-ordered.

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

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

Given the tool's complexity (20 parameters, 6 enums, aggregate vs row modes, join=state, signal-only filters), the description covers the most critical cross-cutting behaviors: the bound requirement, case-sensitivity, join semantics, and interval resolution. The output schema exists, so return values are covered. The description doesn't explicitly mention pagination or cursor behavior, but the schema documents the cursor parameter. It's complete enough for an agent to call this tool correctly in most cases.

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

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

Schema description coverage is 100%, so the schema already documents all 20 parameters thoroughly. The description adds some cross-cutting semantic context: the bound requirement (ticker scope, time window, or firm/action), the case-sensitivity distinction, and the join=state behavior. However, most parameter-level semantics are already in the schema, so the description's incremental value is moderate. Baseline 3 is appropriate.

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

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

The description opens with a clear, specific statement: 'One timeline across every ticker: earnings, dividends, splits, insider filings, analyst actions, plus opt-in signal firings and news.' This names the resource (events), the verb (list), and the scope (across every ticker), and enumerates the event kinds. It distinguishes itself from siblings like get_bars, get_series, and search_news by focusing on the unified event timeline.

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

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

The description explicitly states the requirement: 'Requires at least one bound: a ticker scope (ticker/tickers/universe), a time window (from/to), or firm/action — `q` alone is not a bound.' It also explains when to use alternatives implicitly by describing what this tool covers (events) versus siblings like get_bars (price bars) and search_news (news search). The bound requirement is a clear usage rule that prevents invalid calls.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds useful context by noting that custom signals appear with 'kind: custom' and that the result is a single combined catalog, but it does not explicitly state non-mutating behavior or pagination semantics.

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

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

The description is two sentences and front-loads the main purpose before the usage guidance. The first phrase is slightly stylized and partially redundant with 'built-in signals and custom signals', but overall it is compact and not 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?

This is a simple list tool with an output schema and fully documented optional parameters. The description adds the essential use case and the kind-labeling behavior, making it complete enough for an agent to call correctly without further inference.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no significant parameter-level meaning beyond what the schema already provides; mentioning 'kind: custom' merely reflects the existing enum description.

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

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

The description clearly identifies the tool as a catalog of every queryable signal, both built-in and custom, which distinguishes it from single-signal tools like tickerbot_get_signal. The phrase 'use to discover the signal names and q vocabulary before composing a scan' gives a specific purpose and resource 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?

It explicitly states when to use the tool: before composing a scan, to discover signal names and the q vocabulary. It does not explicitly exclude alternatives or mention when not to use it, but the context is clear enough for an agent to select it appropriately.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It usefully reveals that delisted symbols are included and that rows are identity-only rather than full records. However, it does not mention default page size, pagination, or the read-only nature of the call; the schema covers some of this, but the description itself is minimally transparent.

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

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

The description is two short sentences with no redundancy. The core behavior is front-loaded, and the pointer to the full-row endpoint earns its place as a disambiguator.

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 that an output schema exists and the input schema documents all six optional parameters, the description does not need to restate return values or parameter details. It supplies the missing context: identity-row semantics, delisted coverage, and where to get full data. It is slightly incomplete only in not contrasting this tool with other list/scan 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 100%, so the baseline is 3; the description adds no parameter-level meaning beyond what the schema already provides. It neither clarifies parameter behavior nor introduces constraints, so it does not deserve a higher score.

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 (every symbol tracked), the scope (active or delisted), and the granularity (one identity row each), which is specific and informative. It also distinguishes this list operation from the full-row retrieval via `/v2/tickers/{ticker}`, matching the sibling `get_ticker` tool.

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

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

The description implies when to use the list: when you want identity rows for tracked symbols, active or delisted. It explicitly points to `/v2/tickers/{ticker}` for the full row, giving a clear alternative for a different need. It does not enumerate other alternatives like `scan` or `get_ticker_coverage`, so it falls just short of full routing guidance.

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

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

No annotations are provided, so the description carries the burden. It explains the meaning of `owner: system` and `all`, and notes that `limit` applies to your own universes. However, it does not disclose pagination behavior beyond the cursor parameter, or whether the response includes metadata like total counts. The description is honest and consistent, but not deeply behavioral.

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

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

The description is two sentences, front-loads the core purpose, and packs the key distinctions (`owner: system`, `all`, slug usage) into a compact space. Every sentence earns its place.

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

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

The tool has an output schema, so return values are already documented. The description covers the purpose, the owner semantics, and the downstream use of the result. It could mention pagination behavior more explicitly, but the cursor parameter and output schema cover the essentials.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds context by explaining the semantic difference between `me`, `system`, and `all`, and by noting that `limit` applies to your own universes. This is useful but not a major addition beyond the schema.

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

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

The description clearly states the tool lists universes (both user-owned and built-in), distinguishes the `owner` values, and explains the relationship to other tools. It uses a specific verb ('list') and resource ('universes'), and differentiates from siblings like `tickerbot_get_universe` by describing the enumeration behavior.

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

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

The description explicitly explains when to use this tool: to reference universes, and how the `owner` parameter selects between `me`, `system`, and `all`. It also tells the agent that the resulting slug is used as `universe` on scan, signal, and subscribe tools, which is actionable guidance for downstream usage.

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

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

With no annotations, the description carries the behavioral disclosure burden. It communicates a read-style listing operation and that each delivery includes the sent payload and the response, which is useful. It does not disclose side effects, auth requirements, rate limits, or retention details, though 'recent' hints at a time-bounded result.

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

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

The description is a single front-loaded sentence with no filler. Every phrase earns its place: 'recent', 'for one webhook', and 'what was sent, and what came back' all help an agent select and expect the tool's behavior.

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 rich input schema covers the date filters, pagination, default, and status enum, and the output schema covers return shape, so the short description does not need to restate those. A brief note about read-only semantics or when to first call list_webhooks would round it out, but the core invocation context is present.

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

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

Schema description coverage is 100%, so the input schema already documents every parameter. The description adds little parameter-specific meaning beyond 'one webhook' mapping to the required id. This is the baseline case where 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 clearly identifies the resource as 'deliveries for one webhook', which distinguishes it from sibling list tools such as tickerbot_list_webhooks. The phrase 'what was sent, and what came back' also sets expectations about the returned delivery history. It is clear but does not explicitly state the 'list' verb or name an alternative tool.

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

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

The phrasing 'for one webhook' implies the correct use case: an agent should call this when it already has a webhook id and wants delivery history. However, the description does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternative tools for inspecting webhook configuration.

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

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

No annotations are present, so the description carries the behavioral disclosure burden. It does disclose two genuine behaviors: account-level scope and newest-first ordering. However, it says nothing about pagination mechanics (limit/cursor loop), the default page size of 50, or the read-only safety profile, and the nuanced 'disabled covers user pause and auto-disable' semantics live only inside the schema's status parameter, not the description.

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

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

Seven words in a single sentence with zero filler. The resource, scope, and ordering are all front-loaded, and every word earns its place. This is appropriately concise rather than under-specified.

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

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

With an output schema present and 100% parameter schema coverage, return values and inputs are already handled. The remaining gaps are routing guidance (when to choose this over list_webhook_deliveries or get_webhook) and explicit pagination-loop behavior, though 'Opaque cursor from the previous response' implies it. For a simple list endpoint this is adequate but leaves clear decision-making gaps.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. All three parameters (limit, cursor, status) are well-documented in the schema, including the opaque-cursor contract and the nuanced status enum semantics. The description itself adds nothing about parameters, but the schema fully compensates, so no deduction is warranted.

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 ('webhook subscription'), its scope ('on this account'), and its ordering ('newest first'), which clearly communicates what the tool returns. It is implicitly distinguishable from siblings: get_webhook (singular), list_webhook_deliveries (delivery records, not subscriptions), and the create/delete/update/enable/test mutation tools. A small deduction because it is a noun phrase rather than an explicit verb phrase ('Returns every webhook…'), and it does not name the sibling distinctions.

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 or when-not-to-use guidance. The description never mentions alternatives, exclusions, or the condition that would select this tool over get_webhook or list_webhook_deliveries. The appropriate use case is only implied by the tool name and the nouns in the description.

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

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

With no annotations provided, the description carries the full burden and does disclose meaningful behavior: temporal reads via asof, the flat/restricted grammar (no JOIN or subqueries), and the mode shift to rollup rows with group_by. It does not explicitly state that this is a read-only operation, nor cover side effects, rate limits, or error behavior, though the schema covers most error contracts.

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

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

Five tight sentences with no filler: the core purpose is front-loaded first, followed by grammar constraints, the group_by caveat, and a concrete example. Every sentence carries distinct information and none repeats the schema.

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

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

For a complex 14-parameter tool with two major modes (row and aggregate) plus asof, the description covers the headline semantics well: the query grammar, temporal reads, and aggregate-mode behavior. With a rich output schema present and 100% parameter coverage, the remaining concepts (pagination, having/select, universe scoping) are adequately handled by the schema, so the description selects the right high-value concepts to explain.

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 clearly exceeds it: it explains the q grammar in detail (AND/OR/NOT, comparisons, literals, custom signal expansion, no JOIN/subqueries) and adds meaning to group_by and asof that the schema's short field descriptions only hint at. The example ties q, signals, and semantics together in a way the schema alone cannot.

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 (tickers) and action (return every ticker matching a SQL WHERE clause), with a concrete example. It distinguishes itself behaviorally by noting that group_by produces rollup rows instead of tickers, which separates it from listing/getting tools among the siblings, though it never names a sibling explicitly and the verb is implied rather than stated.

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

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

Usage is implied through the grammar explanation and the concrete example (`gap_up AND market_cap < 2000000000 AND NOT earnings_this_week`), which conveys that this tool screens tickers by signal conditions. However, there is no explicit when-to-use versus when-not-to-use guidance, no mention of alternatives like subscribe_scan or list_tickers, and no exclusions stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that rollups with group_by/having return `truncated: true` instead of paging, and it exposes the SQL-query nature and the `tk` auto-unnest alias. This goes beyond the name and schema, giving the agent a real sense of how the tool behaves, though it does not mention whether the operation is read-only or any performance 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?

The description is five short, information-dense sentences with the core resource and operation front-loaded. Every sentence contributes a distinct fact: SQL querying, row/rollup modes, ticker filtering, full-text search, and truncation behavior. There is no filler or repetition of the detailed schema 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?

Given the tool's complexity, the input schema is exhaustive with 100% coverage, an output schema exists, and the description covers the non-obvious behaviors an agent must know before calling it. The key modes and the truncation-vs-paging distinction are explained, and the schema handles parameter-level details, so nothing essential is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some cross-parameter guidance, such as filtering via the `ticker` param or the `tk` alias in `q`, and notes that `search` is full-text over title and summary. However, most of this information is already present in the parameter schemas, so the description adds marginal semantic value beyond them.

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

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

The description opens with a specific verb and resource: "SQL query over the news archive." It clearly states the main modes (article rows vs. rollups), full-text search behavior, and ticker filtering, which distinguishes it from sibling tools like tickerbot_list_events or tickerbot_get_series.

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

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

The description strongly implies usage by explaining how to filter by ticker, use full-text search, and opt into rollups, but it never explicitly contrasts this tool with alternatives or states when not to use it. An agent can infer the use case but is not directly routed away from similar news/event/listing tools.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses the push model, paid-plan restriction, the distinction between ticker STATE and EVENT payload filters, and that latency follows the ingest cadence rather than being sub-minute. Retries, auth, and rate limits are not covered, but the key operational traits are present.

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

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

Three dense sentences with the core push behavior front-loaded, followed by the pricing constraint and the subtle q/event_q and latency distinctions. Every sentence earns its place with no filler.

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

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

For an 11-parameter subscription tool with a full input schema and an output schema, the description covers the non-obvious behavior an agent would need: push semantics, paid-plan requirements, filter semantics, and delivery latency. Nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by disambiguating `q` ('filters the ticker STATE') from `event_q` ('filters the EVENT payload in the /v2/events grammar') and by explaining latency in a way the schema does not.

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

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

Opens with 'Push new events: we POST your endpoint when events of the kinds you chose land in the archives,' which names a specific verb, resource, and triggering condition. This clearly distinguishes it from sibling scan/signal/ticker subscription tools by focusing on event-kind delivery.

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

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

The description sets a concrete precondition with 'Webhooks need a paid plan (Free has no webhook slots)' and clarifies two filtering modes via `q` vs `event_q`. It does not explicitly name sibling subscribe_scan/subscribe_signal/subscribe_ticker, so exclusions remain implied rather than stated.

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

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

With no annotations, the description carries the transparency burden. It discloses the core behavior—every match-set change triggers a POST to the endpoint—and the paid-plan gating for webhooks. However, it does not mention authentication requirements, rate limits, how to cancel the subscription, or the fact that non-webhook channels are also supported. The description adds some behavioral context but leaves several operational traits undisclosed.

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

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

The description is two tight sentences with no filler. It front-loads the primary behavior, then adds the critical plan constraint and usage phrase. Every clause earns its place.

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

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

Given the tool's complexity—11 parameters, full schema coverage, enums, aliases, and an output schema—the description does enough to orient the agent around the subscription model and the paid-plan constraint. It could mention lifecycle management or alternative delivery channels, but the schema already covers channel mechanics and the output schema handles return values, so the remaining gaps are minor.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the high-level concept that the `q` parameter is a full query and that the tool pushes results, but it does not add parameter-level detail beyond the schema. The schema itself provides thorough explanations for q, channel, cadence, ordering, and aliases.

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

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

The description clearly states the tool's action: it pushes a full query and POSTs to the user's endpoint whenever the match set changes. The phrase 'whole query' distinguishes it from single-signal or ticker subscriptions, and 'Use for alert me when this happens' reinforces the use case. It does not explicitly name sibling tools, but the intent is unambiguous.

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

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

The description provides a clear usage context: use this for alert-style requests that fire when scan results change. It also gives a concrete prerequisite/limitation: webhooks require a paid plan, and Free has no webhook slots. It stops short of explicitly saying when not to use it or naming alternatives like subscribe_signal, so it misses 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?

With no annotations present, the description carries the burden and does state the key behavioral effects: the system POSTs to the user's endpoint whenever a ticker starts matching the signal. It also names the delivery mechanism and the paid-plan limitation for webhooks. It could add persistence/lifecycle details, but the core trigger-and-deliver behavior is disclosed.

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

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

Three short sentences with no filler. The core behavior is front-loaded, followed by the most important constraint and a useful usage tip.

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 rich 100%-covered input schema and presence of an output schema, the description does not need to re-explain every parameter. It covers the high-level purpose, a key constraint, and the universe-scoping default, which is sufficient context for a 13-parameter tool whose details live in 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 and most parameter meaning comes from the schema. The description adds only two small param-related notes—webhook plans and the ticker-omission default—neither of which materially changes parameter understanding beyond 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 opening 'Push one signal: we POST your endpoint whenever any ticker starts matching it' clearly identifies the verb (subscribe/push), resource (a signal), and trigger condition. It also distinguishes this from sibling ticker/scan/event subscription tools by emphasizing signal matching rather than a fixed ticker or scan.

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

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

The description gives useful context by warning that webhooks require a paid plan and explaining how to broaden scope with 'Omit `ticker` to watch the whole universe.' It does not explicitly say when to choose this tool over subscribe_ticker, subscribe_scan, or subscribe_events, so the usage guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the POST-on-match behavior, the paid-plan webhook restriction, and the in-app delivery fallback. It doesn't mention rate limits, idempotency, or what happens on duplicate subscriptions, but for a subscription-creation tool the disclosed behaviors are the critical ones.

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

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

Three sentences, zero filler. The first sentence states the action and trigger, the second gives the key constraint (paid plan), and the third gives the alternative path (in-app). Every sentence earns its place and the most important behavioral facts are front-loaded.

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

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

For a 12-parameter tool with 100% schema coverage and an output schema, the description covers the essential behavioral context: what triggers a POST, the paid-plan gate, and the in-app fallback. It doesn't discuss idempotency or duplicate handling, but the schema's rich parameter documentation and output schema carry the remaining load. A 4 is appropriate given the 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 100%, so the baseline is 3. The description adds value beyond the schema by explaining the core delivery contract (POST when condition matches), clarifying the target_url omission behavior, and noting the paid-plan constraint. It doesn't restate every parameter, but it adds meaning to the most important ones (target_url, q, ticker) and the schema already covers the rest.

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

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

The description opens with a specific verb+resource ('Push one ticker') and immediately states the core behavior: POST to your endpoint when the condition matches. It distinguishes itself from siblings like subscribe_scan and subscribe_events by being ticker-specific, and the webhook vs in-app delivery distinction adds further clarity.

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

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

The description explicitly states when to use this tool (push one ticker with a condition), and provides clear guidance on alternatives: omit target_url for in-app delivery, and the paid-plan webhook requirement tells the agent when this tool is not viable. The schema further clarifies channel inference rules, but the description itself already gives actionable 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?

With no annotations provided, the description carries the disclosure burden and does so well: it states the request is a real POST, is one-shot, never retries, never auto-disables the webhook, and fails with 400 if target_url is missing. These details go beyond the schema and name, giving an agent accurate side-effect expectations.

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

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

Three short sentences with the main action front-loaded and each subsequence sentence adding a distinct behavioral detail. There is no redundant phrasing or unnecessary repetition of schema information.

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

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

For a one-parameter tool with an output schema, the description covers the core purpose, the error condition, and important side-effect behavior. It does not mention whether the webhook must be enabled or permissions required, but these are minor gaps given the tool's low 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?

The sole required parameter 'id' is already fully described in the schema as 'Webhook id' with 100% schema coverage, so the description does not need to repeat it. The description adds no additional paramter semantics, which matches the baseline for high schema coverage.

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

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

The description leads with a specific action ('Send a real-shape test POST') against a specific resource ('your endpoint'), making it clear this is a webhook testing tool. It also distinguishes itself from sibling webhook tools by emphasizing it is a one-shot live test rather than configuration or inspection.

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 tool implies it should be used when you want to immediately validate a webhook endpoint, but it never explicitly states when to use it instead of alternatives like list_webhook_deliveries or create_webhook. It gives clear context in the first sentence but omits when-not-to-use guidance and alternatives.

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

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

No annotations exist, so the definition carries full behavioral burden. The parameter descriptions disclose important side effects: expression re-validation and re-inlining, rename changing the API handle everywhere, refusal while other signals reference the current name, and built-ins answering 404. This is strong behavioral disclosure for a mutating tool.

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

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

The opening sentence is concise and front-loaded with the action, resource, and editable fields. Each parameter description earns its place with a meaningful rule or caveat, with no filler or redundant information.

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

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

Given the rich parameter descriptions and an output schema, the definition covers ownership, built-in read-only behavior, rename side effects, expression grammar restrictions, and the relationship between description and expression. An agent has the needed information to call this tool correctly and safely.

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 parameter descriptions add substantial extra meaning: allowed SQL grammar, forbidden constructs, exact allowed functions, alias behavior for 'name', and rename/reference constraints. These go well beyond basic type or format documentation.

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 specifies a clear action ('Update'), a specific resource ('a custom signal you own'), and the mutable fields (expression, description, or name). This clearly distinguishes it from create/delete variants and from update_universe/update_webhook without requiring the agent to open the schema.

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

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

The phrase 'you own' implies the tool is only for user-created custom signals, and the schema adds a built-in read-only exclusion via 404 behavior. However, it does not explicitly say when to prefer this over create/delete or mention alternatives for updating other resource types, leaving some usage routing 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?

With no annotations provided, the description carries the burden. It does disclose important behavior: system universes are locked from editing, and `tickers` overwrites the full list while `add`/`remove` adjust it incrementally. Missing are mutation side effects, permission requirements, or error behavior on invalid or protected universes; for a write tool this is only partial transparency.

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

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

Two tight sentences, no filler. The first sentence front-loads the action and scope; the second packs the mutation modes and the hard system-universe restriction. Every clause contributes meaning, making this an efficient definition.

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

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

The description covers the core operations, parameter semantics, and a critical business rule (system universes cannot be edited). With full parameter schema coverage and an output schema available, the remaining gaps—like explicit error handling or alternative routing—are minor but keep it from being fully complete for a mutation tool with no annotations.

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

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

The input schema already documents every parameter (100% coverage), so the baseline is 3. The description adds value by grouping parameters into names/description vs members and explicitly clarifying the semantic relationship between `tickers` (replace) and `add`/`remove` (adjust), which is not obvious from individual parameter descriptions alone.

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

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

The description states a specific verb and resource: 'Update one of your universes', and enumerates the editable aspects: name, description, or members. This clearly distinguishes it from sibling create/delete/get universe tools and from update_custom_signal/update_webhook by resource type. The scoping is precise and unambiguous.

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

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

It gives clear context on when to use the tool: updating existing universes, and provides an explicit exclusion: 'System universes cannot be edited'. It also explains the internal choice between `tickers` (replace all) and `add`/`remove` (adjust). However, it does not explicitly name alternatives like create_universe for new universes, so it stops short of full route-guiding.

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

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

With no annotations, the description carries the full behavioral burden and does well by disclosing partial-update semantics, immutability of trigger/channel, and the 400 on unknown fields. It could add more about auth or side effects, but the key behavioral traps are explicitly 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?

Three concise sentences with no filler. The main usage instruction is front-loaded, followed by the most important constraint and error behavior.

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

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

The description covers the main gotchas (immutability, partial update, unknown-field rejection) and the richly described schema plus output schema fill in parameter and return details. A few edge cases like idempotency or permission requirements are not mentioned, but nothing essential is missing for correct invocation.

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

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

Schema description coverage is 100%, so the description does not need to explain individual parameters. The description adds general context about partial updates and unknown fields, but no specific parameter meaning beyond what the schema already provides.

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

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

The description opens with a specific action and resource ('Edit a webhook in place'), and immediately defines the update scope ('send only the fields you want to change'). It also distinguishes itself from sibling tools by calling out immutable trigger/channel and directing to delete/re-create instead.

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

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

The description gives explicit usage guidance: partial updates are expected, and users are directed to delete and re-create when changing immutable trigger or channel fields. It does not explicitly mention alternatives like enable_webhook, but the guidance it provides is clear and actionable for the main decision.

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