longwatch

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 reveals a $0.001 USDC cost per call, that no API key/account is needed, and that an unpaid call returns HTTP 402 with payment requirements. It does not describe the success response, but the main behavioral risks are addressed.

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

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

The first sentence is efficient and front-loaded, and the payment/402 sentence is relevant operational context. However, the final 'Free alternative' sentence introduces unrelated endpoints and does not earn its place in this tool's definition; it adds noise and could misroute an agent.

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

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

The description covers the core condition-check behavior, payment mechanics, and no-auth requirement, which is adequate for basic invocation. However, with no output schema and no annotations, it omits what a successful response contains (e.g., current price, boolean threshold result) and any guidance on response format, leaving a notable gap for a paid 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?

Only coin has a schema description (25% coverage), so the description must compensate for above, below, and move_pct_24h. It does so by identifying USD thresholds (above/below) and the 24-hour move condition, which gives agents the core semantic needed to use those parameters. It does not spell out constraints or mutual exclusivity, but the coverage is far better than the schema 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 opens with an explicit action and resource: checking a CoinGecko asset price and its current relation to a USD threshold or 24-hour move condition. This clearly separates check_crypto_price from siblings like check_insider_trades or check_sec_filings, and the title reinforces the immediate/on-demand nature.

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

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

The word 'currently' and the title 'now' imply this is for a point-in-time check rather than watch_crypto_price-style monitoring, but the description never explicitly says when to prefer this tool over an alternative. The 'Free alternative' paragraph is off-topic (NVDA sample, 24h watch) and adds no help in choosing among sibling 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?

No annotations are provided, so the description carries the full burden. It transparently discloses the $0.001 USDC cost, the no-API-key/no-account access model, the 402 payment-required behavior, and the parsed output fields. This is strong behavioral disclosure for a paid endpoint, though rate limits and data freshness are not 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?

Every sentence earns its place: the core capability, parsed fields, cost and auth model, failure behavior, and free alternatives. It is front-loaded with the main purpose and contains no filler or repetition.

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

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

For a two-parameter tool with no output schema and no annotations, the description covers the critical operational details: what it returns, how payment works, what happens without payment, and no-wallet alternatives. The vague 'recent' timeframe and lack of monitoring-sibling guidance are minor gaps.

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

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

With 0% schema description coverage, the description's 'for a ticker or CIK' provides essential meaning for cik and ticker. However, it does not clarify expected formats, whether one is required despite the schema listing zero required parameters, or behavior when both are provided. This is partial compensation, not full.

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: 'Get recent Form 4 insider transactions for a ticker or CIK.' It also lists the parsed fields (buyer/seller, shares, value, transaction type, 10b5-1 status), making the tool's scope unmistakable and easily distinguishable from generic siblings like check_sec_filings.

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 around payment, x402, and free alternatives, but it does not explicitly say when to choose this tool over watch_insider_trades or other monitoring siblings. The 'Free alternative' is about avoiding payment, not about tool selection, so 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?

With no annotations provided, the description fully carries the behavioral burden and does so thoroughly. It discloses session-only scope, the $0.001 USDC cost via x402, no API key/account requirement, the 402 response when unpaid, and per-type parsing behavior such as 8-K decoding and Form 4 parsing.

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

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

The description is dense and front-loads the most important constraint (session-only) before other operational details. Every sentence carries useful information, though it is a single block of text that could benefit from more visual structure.

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

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

For a 14-parameter tool with no output schema and no annotations, the description covers the most critical operational facts: type-specific required fields, cost, payment behavior, and alternatives. It omits context for body, method, and the expected_* payment parameters, and the response format is only hinted at, so it is not fully 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?

The description adds critical cross-parameter constraints not present in the schema, such as 'price needs coin plus above, below, or move_pct_24h' and 'edgar needs ticker or cik.' These are essential for valid invocation. However, several parameters (body, method, expected_scheme, expected_network, expected_amount_atomic) remain unexplained in both the schema and the 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 states the tool performs a one-time snapshot check of a source, explicitly contrasting it with persistent watch behavior. It enumerates the supported source types and distinguishes itself from create_watch and watch_* siblings by saying 'no watch, no cursor' and 'Use when you will not come back.'

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 an explicit usage condition ('Use when you will not come back') and a direct alternative ('If the job spans runs, create_watch instead'). It also points to free trial endpoints. However, it does not explicitly explain when to prefer the specialized check_* sibling tools over this generic check_now.

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 of behavioral disclosure. It does well by revealing the $0.001 USDC cost, the x402 payment mechanism, the absence of API key/account requirements, and the 402 response for non-payment. It does not detail output structure or failure modes, but the key invocation-relevant behaviors are disclosed.

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

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

The description is front-loaded with the core purpose and then provides relevant payment and alternative-path information. Each sentence adds useful context; the word 'now' is slightly redundant with the title and 'one-session lookup,' but this is minor.

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

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

For a simple one-parameter tool with no output schema and no annotations, the description covers purpose, usage context, cost, authentication, and payment-failure behavior. It does not explicitly describe the return payload, but 'latest items' gives a reasonable expectation, and no major gap prevents correct invocation.

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

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

The input schema has 100% coverage and describes the url parameter as 'public RSS or Atom feed URL.' The description repeats this same idea without adding new semantic detail, so it does not meaningfully improve on the schema. Baseline 3 is appropriate.

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

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

Description uses a specific verb and resource: 'Read the latest items from a public RSS or Atom feed now.' It clearly differentiates from watch-style siblings by adding 'Use for a one-session lookup,' making the one-shot versus recurring distinction 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 explicitly states when to use the tool ('for a one-session lookup') and gives free alternatives for users who do not want to pay. However, it does not directly name watch_rss_feed as the recurring-monitoring alternative, so the sibling routing 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?

With no annotations, the description carries the full behavioral disclosure burden and does so well by revealing the $0.001 USDC cost, x402 payment mechanism, no-API-key requirement, and the 402 response when payment is missing. It also discloses that 8-K items are decoded and Form 4 transactions are parsed, which explains processing behavior beyond the schema.

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

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

The description is three sentences with no wasted wording: the core capability is front-loaded, followed by pricing/payment behavior, then free alternatives. Every sentence adds useful information and the structure is easy to scan.

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

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

Given the absence of annotations and output schema, the description is fairly complete: it covers purpose, cost, payment failure, and free alternatives. Still, it omits details an agent might need, such as accepted form identifiers, whether ticker and cik are mutually exclusive, response structure, and error behavior beyond the 402 case.

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

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

Schema description coverage is 0%, so the description must compensate for bare parameter names. It does explain that the tool accepts 'a ticker or CIK' and hints at relevant form types via '8-K items' and 'Form 4 transactions', but it never explicitly documents the forms parameter, its allowed values, formats, or the relationship between ticker, cik, and forms. This is partial compensation at best.

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 gets recent SEC filings for a ticker or CIK and provides decoded 8-K items and parsed Form 4 transactions. This is a specific verb-resource pairing that makes the main purpose obvious. However, it does not differentiate itself from the sibling check_insider_trades, which likely overlaps on Form 4 data.

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

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

The description gives useful context about the paid per-call model and points to free alternatives ('Free alternative: GET https://longwatch.dev/demo... or POST https://longwatch.dev/try...'). It does not explicitly say when to choose this tool over sibling tools like check_insider_trades or watch_sec_filings, so the guidance is helpful but incomplete.

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 transparently covers the $0.001 USDC cost, x402 payment mechanism, no-API-key requirement, and the 402 response when payment is absent. It does not detail the exact structure of 'normalized text metadata' or rate limits, but the key operational behaviors are 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 sentences with no wasted words: the action, use case, pricing, failure mode, and free alternatives are all packed efficiently. The primary purpose is front-loaded in the first sentence, and every subsequent sentence adds actionable 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 single-parameter fetch tool, the description covers purpose, pricing, auth, failure behavior, and free alternatives. The lack of an output schema is partially mitigated by 'normalized text metadata,' though a bit more detail about the return format would make it fully complete. Overall, an agent has enough context to decide whether and how to invoke it.

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

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

The input schema already fully documents the only parameter, 'url', as a public http(s) page URL, so schema coverage is 100%. The description reinforces that the page must be public and mentions normalized text metadata, but it does not add new parameter-level semantics beyond what the schema already provides. A 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 opens with a clear verb and resource: 'Fetch a public web page now and return normalized text metadata.' This states exactly what the tool does and distinguishes it from sibling tools like check_sec_filings or check_rss_feed. The phrase 'Use for a one-session lookup' also separates it from the watch_* persistent-monitoring siblings.

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

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

The description explicitly says to use it for a one-session lookup, which gives a clear when-to-use signal. It also mentions free alternatives for demo/trial purposes, which helps agents avoid unnecessary paid calls. However, it does not explicitly name watch_web_page as the alternative for ongoing monitoring, leaving that connection 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 supplied, the description carries the burden of behavior disclosure. It reveals that the call is unpaid, costs $0.001 USDC via x402 on Base, requires no API key or account, and that an unpaid call returns 402 with payment requirements. It does not fully describe output or failure behavior, but the cost and no-payment behavior are well disclosed.

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

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

The main purpose is front-loaded, followed by cost and behavioral details, and then free alternatives. The free-alternative sentence is slightly promotional but useful for routing users away from unnecessary paid calls. Each sentence adds some actionable information, so the length is justified.

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 has six parameters, a nested body object, and no output schema, the description gives useful cost and behavioral context but omits how the validation result is returned and how each parameter should be populated. The core use case is clear, but an agent would still have to infer some parameter and response semantics.

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

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

Schema description coverage is 0%, so the description must compensate, but it only partially does. It mentions validating scheme, amount, network, and recipient, which maps to expected_scheme, expected_amount_atomic, and expected_network, but it does not explain url, body, method, or what 'atomic' means for the amount. Parameter names are mostly self-explanatory, but the description adds only limited semantic 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 clearly states the tool's action: send an unpaid request and validate the endpoint's HTTP 402 challenge, accepted networks, scheme, amount, and recipient. It is specific about the resource and one-time validation intent, but it does not explicitly compare itself to the closely related watch_x402_endpoint sibling, so it stops short of a full 5.

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

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

The description gives clear context for when to use the tool—when you need to validate an x402 endpoint—and also gives explicit free alternatives (the longwatch.dev demo and trial endpoints) to avoid paying. It does not explicitly contrast with watch_x402_endpoint or other sibling tools, so usage guidance is strong but not exhaustive.

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, and it does so thoroughly. It discloses the cost per call, the fact that no API key or account is needed, the 402 response for missing payment, the inclusion of a baseline and 7 days of polling, and the need to persist watch_id and key for later polling. This is far beyond the average tool description and gives the agent a realistic picture of side effects and prerequisites.

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 long but every sentence carries distinct, high-value information: core behavior, persistence model, type requirements, payment model, and free alternatives. The most important usage constraint is front-loaded, and the payment/error behavior is placed precisely where it matters. No filler is present.

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, 16 parameters, no output schema, and a large sibling set, this description is remarkably complete. It covers what the watch does, how to pay, what happens without payment, how to poll results, which parameters are required per type, and where to go for a free alternative. The only minor missing detail is a fuller return-format description, but the instruction to persist watch_id and key provides enough guidance.

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 69%, and the description adds critical conditional logic that the schema alone lacks: 'url/rss/x402 need url; price needs coin plus a threshold; edgar needs ticker or cik.' This meaningfully helps an agent form valid inputs. It does not enumerate every parameter, but the schema already documents most of them with examples, so the description compensates well for the main ambiguity.

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, concrete statement: 'Keep watching a source between agent runs and alert when it changes.' This names a clear verb, resource, and standing behavior that distinguishes create_watch from the check_* siblings, which are one-off checks. It also positions itself relative to poll_alerts and the free trial endpoints.

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 strong guidance on when to use this tool: for persistent watching between runs, with type-specific requirements spelled out. It also names a free alternative for demos and 24-hour trials, which helps an agent decide not to call create_watch when a wallet-free option is acceptable. It stops short of explicitly enumerating when-not cases, such as 'use check_* for a one-time immediate check,' so it misses full 5-level explicitness.

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

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

With no annotations, the description must fully disclose behavior. It only says 'Stop and delete' without clarifying side effects (e.g., irreversibility, required permissions, or impact on related resources). The irrelevant 'Free' remark adds confusion.

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

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

The description is short but includes irrelevant filler ('Free. Free — no payment required.') that detracts from clarity. The useful first sentence is not enough to earn a higher score.

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

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

For a deletion tool with no annotations and no output schema, the description fails to cover return behavior, error conditions, or usage context. Sibling tools exist but are not referenced. The description is incomplete.

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

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

Schema description coverage is 100%—both parameters have descriptions. The tool description adds no extra parameter context beyond what the schema already provides. Baseline score of 3 is appropriate.

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

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

The description states 'Stop and delete a watch' with a specific verb ('Stop and delete') and resource ('a watch'). This clearly distinguishes it from sibling tools like create_watch, check_now, and poll_alerts.

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 provided on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., needing a valid watch from create_watch) or when not to use it.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does well by revealing the payment model, the 7-day renewal window, that polling keeps the watch alive, and that no API key or account is required. It does not cover error behavior or exact return payload, but the most important non-obvious behaviors are disclosed.

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

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

The core usage is front-loaded and the structure is logical: what it does, how to pass since, then cost/auth context. However, the paid-poll explanation is repeated several times in slightly different phrasing ('New paid watches include 7 days', 'After that window...', 'Free through...'), which makes the description wordier than necessary.

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 three-parameter tool with no output schema and no annotations, the description covers the essential context: required IDs, cursor semantics, cost, renewal, and authentication. It could be more explicit about the format of returned alerts or when to prefer sibling tools, but nothing critical is missing for making a correct call.

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

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

The schema already documents all three parameters, so the baseline is 3. The description adds meaningful guidance for the 'since' parameter by framing it as the last sequence number seen and explaining that the response carries a new cursor. This goes beyond the schema without redundancy.

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 operation: polling a watch for new alerts since the last run. It adds concrete semantics with 'since={last seq you saw}' and mentions the response cursor. It does not explicitly differentiate itself from sibling poll_trial, so it stops short of a 5.

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

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

The description implies when to use the tool: you have an existing watch with a known sequence, and you want to fetch what's new since your last poll. It also explains the polling/cost lifecycle, but it never names alternatives or states when not to use this tool versus siblings like poll_trial or check_now.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool is free and that the response carries a new cursor, which is useful. However, it does not disclose authentication needs, error behavior when the trial has expired, or whether the operation has any side effects.

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

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

The first sentence is well front-loaded and the lifecycle guidance is useful, but the description repeats the same cost point twice: 'Free.' and 'Free — no payment required.' This redundancy weakens an otherwise compact description.

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

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

For a simple polling tool with complete schema coverage, it covers the cursor contract, trial expiration path, and cost. Since there is no output schema, it at least indicates the response carries a new cursor, though it does not describe the alert payload 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 coverage is 100%, so the baseline is 3. The description adds real semantic value by defining since as the last sequence number seen and stating the response returns a new cursor, which clarifies the continuation pattern beyond the raw schema.

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

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

Uses a specific verb 'Poll' plus a specific resource, 'trial watch created by try_watch', which clearly separates it from siblings like create_watch, delete_watch, and poll_alerts. The title reinforces the same resource without mere tautology.

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

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

Explains when to use the tool: pass since={last seq seen} while polling a trial watch, and explicitly points to create_watch once the trial expires, including the 7-day paid polling renewal detail. It does not explicitly contrast with poll_alerts for paid watches, so it stops short of a 5.

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

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

With no annotations present, the description carries the full burden, and it does a good job disclosing key behavioral traits: no payment/account needed, 24-hour trial duration, one active trial per caller, no webhooks, and free. It stops short of describing what happens when the trial expires or how to retrieve trial alerts, but the most important constraints are 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 concise and front-loaded with the core purpose and key differentiator. The phrase 'Free — no payment required' is slightly redundant with the earlier 'no payment,' but overall every sentence contributes meaningful constraints and guidance.

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 workflow and limitations, but with 14 parameters and no output schema, it is not fully complete. It does not explain what the tool returns after creating a trial watch or how the agent should retrieve the alerts, despite the sibling poll_trial tool existing for that purpose. The reference to create_watch helps, but the missing next-step workflow leaves a gap.

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

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

Schema description coverage is 64%, and the description adds value by pointing to create_watch for shared parameter semantics and listing the five types. However, it does not explain the undocumented parameters (e.g., body, method, expected_scheme, expected_network, expected_amount_atomic), nor does it clarify type-specific parameter applicability beyond what the schema already states.

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

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

The description clearly identifies the action ('Create a free trial watch') and differentiates it from the paid sibling create_watch by emphasizing 'no payment, no wallet, no account' and 'trial runs for 24h.' It also explicitly lists the supported watch types, so an agent can understand exactly what the tool does without confusion.

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 usage context: 'Use this first to see what the alerts look like before paying.' It also states important limitations ('one at a time per caller' and 'cannot use webhooks'), which helps an agent decide when this tool is appropriate. However, it does not explicitly state when to use create_watch instead, relying on implication rather than a direct when-not-to-use condition.

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

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

With no annotations, the description carries the full burden and it delivers: per-call cost in USDC via x402, no API key/account requirement, 402 behavior without payment, alert-once semantics, hysteresis before re-arming, 7-day polling, and optional signed webhook push. This is unusually complete behavioral disclosure.

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

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

Core behavior and cost are front-loaded in tight phrasing. The last sentence about the free NVDA Form 4 sample and trial URLs adds useful cost-avoidance guidance but is slightly noisy and tangential to crypto-price watching.

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 operational context is strong: pricing, payment flow, duration, and webhook option are all covered. However, with no output schema, no return/alert-delivery detail, and unresolved semantics for three of six parameters, an agent cannot fully infer the correct complete invocation from this description alone.

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

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

Schema coverage is only 50%, and the description does not make up the gap: above, below, and move_pct_24h are left bare, and move_pct_24h in particular is ambiguous. The generic 'threshold/hysteresis' wording does not map to these parameters or explain boundary behavior.

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

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

States a specific action and resource: it monitors a crypto price across agent runs and alerts once on threshold crossing, with hysteresis and 7-day polling. This clearly differentiates it from one-shot check tools like check_crypto_price by emphasizing persistence between runs.

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 usage context: use when you need a priced, persistent crypto-price watch with 7 days of polling and optional webhooks. It also points to free alternatives, including a 24h watch without a wallet, but it does not explicitly say when not to use the tool versus sibling watch/check 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 full disclosure burden and does it well: it reveals the payment requirement ('Costs $0.005 USDC per call via x402 (Base)'), the auth model ('no API key, no account'), the failure mode ('Calling without payment returns 402 with the payment requirements'), and the polling duration ('Includes 7 days of polling'). The only notable omission is what a successful watch returns or how results are delivered beyond the webhook hint in the schema.

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

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

Four sentences, each carrying distinct, non-redundant information: purpose, duration, cost plus error behavior, and free alternatives. The purpose is front-loaded in sentence one, and concrete numbers ($0.005, 7 days, 24h, 402) make every clause actionable. No filler or restatement of the title.

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

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

Given there is no output schema and no annotations, the description must stand alone for invocation decisions — and it covers operational essentials thoroughly (payment, auth, error path, duration, trial alternatives). The real gaps are the cik/ticker selection semantics (which identifier to pass under what condition) and the undocumented success-response behavior for a paid, stateful API. These are meaningful but do not prevent an agent from attempting a correct call, especially with the 402 fallback documented.

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 exactly 50%: webhook and idempotency_key are well documented in the schema, but cik and ticker have no descriptions. The tool description adds only the 'company' context and does not clarify the critical relationship between cik and ticker — whether they are alternatives, both required, or which takes precedence (schema lists zero required parameters). At the 50% coverage boundary, the description neither compensates for the gap nor contradicts it, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Monitor a company between agent runs for new Form 4 insider buys, sells, grants, and tax withholding.' This precisely narrows the scope to SEC Form 4 insider-trade monitoring, distinguishing it from siblings like watch_sec_filings (general SEC filings) and check_insider_trades (one-shot check rather than a watch). The title 'Watch a company for insider trades' reinforces the purpose without being a mere tautology.

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: monitoring happens 'between agent runs,' lasts '7 days of polling,' and costs $0.005 USDC via x402 with alternatives offered — 'Free alternative: GET https://longwatch.dev/demo... or POST https://longwatch.dev/try for a 24h watch.' This tells an agent the cost/benefit tradeoff and trial paths. However, it never explicitly excludes sibling tools (e.g., 'use check_insider_trades for one-time queries'), leaving the watch-vs-check distinction implied by naming only.

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 disclosure burden. It transparently covers payment requirements ($0.005 USDC), the 402 response if unpaid, the 7-day polling window, the per-new-item alert behavior, and free alternatives. It does not describe the alert payload or webhook behavior in depth, but the schema covers the webhook field.

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

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

The description is compact and front-loaded with the core purpose, followed by cost, payment behavior, and free alternatives. Every sentence contributes actionable information, and the direct URLs for the free trial are efficient additions.

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 key aspects an agent needs to select and call the tool: what it does, how long it runs, cost, payment failure behavior, and free alternatives. It does not describe the return value or alert payload, and with no output schema, that is a minor gap in completeness.

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 describes all three parameters with 100% coverage, so the baseline is 3. The description adds useful context about RSS/Atom feed types and cost, but does not meaningfully elaborate on the 'url', 'webhook', or 'idempotency_key' parameters beyond what the schema states.

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

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

The description states a specific action ('Monitor an RSS or Atom feed') and a concrete outcome ('alert once per new item'). It clearly distinguishes this from 'check_rss_feed' by emphasizing persistent monitoring between agent runs rather than a one-time check.

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 a clear use context: monitoring between agent runs, with 7 days of polling, and explicitly provides free alternatives for trying the service. It does not explicitly name the sibling 'check_rss_feed' as the one-time alternative, so the when-not-to-use guidance is slightly 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 burden and does substantial work: it discloses the $0.005 cost, x402 payment mechanism, no-API-key/no-account requirement, 402 failure behavior, and 7-day polling window. It does not reveal success-response shape or cleanup/cancellation semantics, but the payment and persistence behavior 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?

Three sentences, each earning its place: behavior/duration, cost/payment failure, and free alternatives. Front-loaded with the core monitoring purpose before payment details.

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

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

Covers the main operational facts (what is watched, how long, what it costs, paywall behavior) and the schema handles webhook/idempotency_key. But with no output schema and no annotations, the absence of success-response behavior, required identifier semantics, and how a watch is later resolved leaves meaningful gaps for a paid, nested-parameter 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 only 40%, and the description does not compensate for the undocumented cik, ticker, or forms parameters: it never says whether a company identifier is required, whether cik/ticker are alternatives, or what form strings are allowed. It only implies the content types via '8-K events' and 'Form 4 trades,' leaving the agent to guess.

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

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

States a specific action—'Monitor a company between agent runs'—and a concrete resource scope: SEC filings, decoded 8-K events, and parsed Form 4 trades. The 'between agent runs' phrasing and 7-day polling clearly separate it from one-time check siblings like check_sec_filings.

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

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

Provides clear context: long-running monitoring with 7 days of polling, plus explicit free alternatives (demo link and /try) for when payment isn't wanted. However, it does not explicitly contrast check_sec_filings or state when a one-time check is preferable, so it stops at clear context rather than full when/when-not guidance.

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

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

With no annotations, the description carries the burden and discloses key behaviors: paid $0.005 USDC via x402, no API key/account, 402 on missing payment, 7-day polling, and public-page limitation. It does not cover response format or watch lifecycle, but the crucial cost/payment behavior 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?

Three sentences, front-loaded with the core purpose, then pricing, then error/alternatives. No filler; every sentence carries operational information an agent needs before calling.

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 payment prerequisites, error behavior, retention, and what kind of alert is produced. It lacks an explicit statement of the immediate API response/return value, which matters because there is no output schema, but the essential 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%: url, webhook, and idempotency_key are already documented there. The free-text description adds no extra parameter-level detail, so the baseline of 3 applies.

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

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

The description opens with a clear verb-resource pair: 'Monitor a public web page' and specifies the output ('alert with added and removed text'). It also frames the tool as continuous ('between agent runs'), separating it from one-shot sibling check tools.

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

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

It clearly establishes use for ongoing monitoring ('between agent runs', '7 days of polling') and points to free demo/trial endpoints as alternatives. It does not explicitly name sibling check tools as the alternative for one-time checks, but the context is unambiguous enough.

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

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

No annotations were provided, so the description carries the full behavioral burden. It discloses that probes do not attach payment, unpaid calls return 402 with payment requirements, polling lasts 7 days, each call costs $0.005 USDC, and no API key/account is needed. This is strong behavioral disclosure for a paid x402-style 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 front-loaded with the core monitoring behavior, then gives cost, auth posture, 402 behavior, and free alternatives. Each sentence adds operational value and there is 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?

Given no annotations, no output schema, and 8 parameters, the description does a good job on payment flow but not a complete job. It does not explain what a successful response looks like, how to supply payment via x402, or how the optional request-shaping parameters like method/body/webhook/expected_* interact. These are material gaps for correct invocation beyond the happy-path url-only call.

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

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

Schema description coverage is only 25% and the description does not enumerate the individual parameters. It hints at domain concepts like price, network, scheme, and recipient, which loosely map to expected_amount_atomic, expected_network, and expected_scheme, but body, method, webhook, and idempotency_key receive little or no meaning beyond their names/schema stubs. For an 8-parameter tool, this is a clear gap.

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

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

Description opens with a specific verb and resource: 'Monitor an x402 endpoint for downtime and changes to its payment challenge, price, network, scheme, or recipient.' It also says 'Includes 7 days of polling,' which clearly distinguishes this watch-style tool from the check_* siblings, especially check_x402_endpoint. This is far beyond a tautology.

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 practical selection context: it costs money, needs no API key/account, includes 7 days of polling, and offers free alternatives when no wallet is available. It does not explicitly compare to check_x402_endpoint or other watch_* tools, but the '7 days of polling' language plus the free-trial alternative makes usage situation reasonably clear.

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