Market Data

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

Annotations already establish the tool as read-only and non-destructive. The description adds the method (sitemap walking and detail page scraping) but does not disclose important behavioral quirks like closed jobs or that max_items is a target, not a guarantee—those details are confined to parameter descriptions.

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 exceptionally concise: two sentences that state the source, method, output shape, and pricing, with no filler or redundant information. It is front-loaded and every word adds value.

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

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

For a simple read-only job scraper with a rich schema and strong annotations, the description covers the essential context: source, method, output, and cost. However, it omits usage boundaries and the non-guaranteed item count in the main text, relying on the schema for those nuances.

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 main description does not add parameter-level semantics, but each parameter already has a rich, detailed description in the input schema, covering behavior like 'target, not a guarantee' and rough recency filtering.

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 function: it returns job postings from Azerbaijan's boss.az via sitemap and structured markup, and specifies the output fields ('One row per posting: title, company, location, posted date, link'). This distinguishes it from sibling job tools by naming the exact site and region.

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 use case is clear—this tool is for retrieving boss.az job listings—but it does not explicitly mention when not to use it or offer alternative tools for other regions or job boards. There are no exclusions, but the context is sufficiently clear 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?

Annotations already mark the tool as read-only, open-world, and non-destructive. The description adds useful behavioral context: it uses a public JSON API, requires no login/browser/proxies, and has a cost of $0.02/call. This goes beyond the annotations, though it doesn't cover rate limits or error handling.

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

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

Two sentences, front-loaded with the core action and resource. Both sentences add value: the first explains function and source, the second covers constraints and cost. No fluff.

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

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

Given the good annotations (readOnly, non-destructive) and high schema coverage, the description is largely complete. It explains the source, auth requirements, cost, and input format. However, with no output schema, it doesn't describe the return structure or pagination behavior, so it's 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?

Schema description coverage is 100% for both parameters, so the description doesn't need to add much. The description mentions 'by region and category,' which aligns with the `items` parameter but doesn't add any detail beyond the schema's thorough format explanation. Baseline 3 applies.

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

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

The description uses a specific verb ('Pull') and identifies the exact resource ('live classified ad listings ... from Chotot's own public JSON API by region and category'). It clearly differentiates from sibling scrapers by naming Chotot Vietnam and listing example categories.

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

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

No explicit when-to-use or alternatives are provided; however, the description implies usage for Chotot Vietnam listings and highlights convenience ('No login, no browser, no proxies'). It doesn't mention exclusions or compare to other scraper tools, so it's only implied.

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

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

Even with readOnlyHint=true and destructiveHint=false annotations, the description adds valuable behavior context: it returns matches sorted by most recently updated, includes a direct study URL, and discloses the cost per call ($0.02) and settlement method. This goes beyond annotation basics.

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 information-dense sentences, perfectly front-loaded with the core purpose and quickly conveying output, source, cost, and access requirements. No wasted words.

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

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

Given that there is no output schema, the description compensates by listing the exact returned fields and the sort order. It covers tool purpose, data source, legal/access constraints, and cost, making it a self-contained explanation for an agent.

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 does not add extra parameter meaning beyond what the schema already provides; it only mentions output fields and sorting, which are not parameter-specific.

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 watches conditions, drugs, or sponsors for clinical trials and returns specific fields (NCT id, status, phase, sponsor, URL). It distinguishes from sibling tools by focusing on clinical trials and citing the official ClinicalTrials.gov API v2.

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

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

Provides clear context for usage: it monitors new and updated trials via the official API, is free, and requires no API key or login. It does not explicitly name alternatives or exclusion criteria, but the domain specificity and 'official' designation imply when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so safety profile is covered. Description adds meaningful behavior: lists returned fields, notes 'public' listings, and includes price per call ($0.02) — all beyond annotations. No mention of failure modes or pagination, but the core behavior is 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?

Two concise sentences – first states purpose, second adds cost/geo context. Every word earns its place, no repetition of schema details.

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

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

For a simple read-only search tool with no output schema, the description covers purpose, countries, and return fields. It doesn't discuss pagination, error handling, or result limits, but given the minimal scope and strong annotations, it's nearly complete. Slight deduction for missing limits on result count.

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 already covers 100% of parameters with descriptions and examples (cc:query format, maxConcurrency range/default). Description adds only generic 'by keyword' phrasing, which doesn't meaningfully extend the schema's detailed examples like 'mx:ventas'.

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 specific verb 'Search' + resource 'Computrabajo' + specifies countries and return fields (title, company, location, URL, posted-when). This distinguishes it from sibling job scrapers like boss-az or xing-jobs by naming the platform and geography.

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?

Description clearly implies use case (keyword search on Computrabajo LatAm) but provides no explicit when/when-not guidance or mention of alternatives among sibling job tools. It relies on the country list to guide selection rather than comparing to other scrapers.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds valuable context beyond annotations: cost per call ($0.03), payment rail (x402), and the exact output structure. It does not mention rate limits or pagination quirks, but the schema describes max_pages as sequential fetching.

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 dense sentence that conveys the action, resource, output fields, and pricing without excessive padding. The appended '— $0.03/call, x402' is a slight aside but provides useful cost context. It front-loads the core action effectively.

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

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

For a simple read-only scraper with well-documented schema and annotations, the description covers the core purpose, the structured return fields, and the cost. Since no output schema is present, listing the fields compensates well. Minor details like pagination sequencing are left to the param descriptions, which is acceptable.

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

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

The input schema provides descriptions for all three parameters (query, max_items, max_pages) with 100% coverage, so the description does not need to explain them. The description itself adds no extra parameter-specific meaning, so it stays at the baseline of 3.

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

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

The description clearly specifies the action ('Search'), the target ('Detik news'), and enumerates returned fields (headlines, excerpts, timestamps, sections, images, canonical URLs as structured rows). This differentiates it from sibling scrapers that target different sites, making it 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 clearly implies its use case—Detik news search by keyword—and gives enough context for an agent to select it. It does not explicitly state when to use it over alternatives or provide exclusions, but the domain specificity makes the intended scenario obvious.

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

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

Annotations already declare readOnlyHint=true, so no extra safety signal is needed. The description adds useful behavioral details: 'No login, no browser, no proxies' and a per-call cost, which goes beyond the annotations.

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

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

The description is concise and front-loaded with the main action, but includes a marketing phrase ('one of Turkey's biggest real-estate classifieds portals') that doesn't carry functional value. Overall it's efficient and readable.

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 no output schema, and the description does not explain what fields the returned listings will contain or how pagination works. It covers the essential use case but leaves a clear gap in expected output structure.

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

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

Schema description coverage is 100%, with each parameter fully documented in the input schema. The description only mentions deal type and property type at a high level, adding no extra semantic value 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 verb 'Pull', the resource 'Emlakjet.com', and the scope 'Istanbul', with a specific focus on deal type and property type. It distinguishes itself from siblings by its geographic and source specificity.

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 use when the user needs live apartment/housing listings from Istanbul, with no login or browser required. It doesn't explicitly name alternative tools, but the Istanbul focus and portal name provide clear context for when to use 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?

Annotations already cover read-only and non-destructive behavior. The description adds extra transparency by disclosing the cost ($0.02/call), the official openFDA data source, and what data is returned (application status, sponsor, latest submission, recall details). This goes beyond the annotations' safety profile, though it doesn't mention rate limits or update frequency.

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 in the first sentence. Every sentence provides value: data source, output details, and cost. No filler or redundancy.

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

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

Although there is no output schema, the description explains the kind of return data (application status, sponsor, submission, recall details). For a moderate-complexity tool with a well-described schema, this is sufficient context to understand what the tool does and returns. It doesn't fully explain how 'watch' behaves (e.g., alert vs. snapshot), but that's a minor gap.

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

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

The input schema already provides 100% description coverage for parameters, including queries, limit, dataset, and maxConcurrency. The description adds no additional parameter-specific meaning; it only restates that queries are drug/company names (already in the schema). Thus the 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 clearly states the tool's purpose with a specific verb ('Watch') and resource ('drugs or companies') for FDA approvals and recalls. It distinguishes itself from sibling tools by specifying the FDA domain and mentioning 'Official openFDA data', making its unique scope evident.

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

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

The description provides clear context for when to use the tool: monitoring FDA approvals and recalls. It mentions the official data source, free access, and per-call cost, which helps the agent decide if it fits the user's needs. However, it does not explicitly state when not to use it or mention alternatives 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?

Annotations provide a safety profile (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false). The description adds valuable beyond-annotation context: the $0.05/call cost, x402/USDC payment mechanism, and a clear independence disclaimer. This helps the agent anticipate cost and trust implications without contradicting annotations.

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

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

The description is extremely concise: two sentences plus a payment clause. It is front-loaded with the action and resource, then provides essential cost and affiliation caveats. No wasted words.

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

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

The description alone is brief, but the surrounding input schema is exceptionally detailed—covering all parameters, thresholds, cost caps, and output expectations in the schema's own description. The tool description adds the cost/payment and independence context that the schema lacks. With no output schema, the description still gives enough outcome context, and the schema's top-level description fills in the batch-size detail.

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

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

Schema coverage is 100% with rich per-parameter descriptions, so the baseline is 3. The description adds no extra parameter-level 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 uses a specific verb ('Convert') and identifies the exact resource ('official PPS contract aggregates') and the output ('buyer-agency demand priorities'). The title 'Korea G2B Contract Demand Radar' further distinguishes it from generic sibling tools like gov-tender-radar.

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 or exclusion guidance compared to alternatives. However, the Korea G2B domain is clearly implied by the title and description, giving some context for when this tool applies. No alternatives are named.

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

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

Beyond the annotations (readOnlyHint, openWorldHint, destructiveHint), the description discloses key behavioral traits: no API key or browser required, reliance on the public TED search API, cost of $0.02/call and settlement currency (USDC on base). It also lists the returned fields (title, buyer, country, CPV codes, deadline, notice URL), which is valuable since no output schema exists.

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 dense sentences, front-loaded with the primary purpose and followed by operational constraints and pricing. Every clause earns its place, with no redundant wording or repetition of schema details.

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

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

For a read-only search tool with four parameters and no output schema, the description adequately covers purpose, source data, return fields, authentication constraints (none needed), and cost. It is complete enough for an agent to select and call the tool 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 description coverage is 100%, and each parameter already has a detailed description in the input schema (e.g., 'ISO 3-letter buyer-country code to AND into every query'). The tool-level description adds 'keyword or CPV code' context but does not meaningfully enhance understanding of individual parameters beyond what the schema already explains.

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 ('Search') and clearly defines the resource ('EU public-sector tenders (TED Europa)') and the filtering options ('by keyword or CPV code, optionally filtered by buyer country'). It distinguishes itself from sibling tender tools like 'uk-public-tender-lead-alert' and 'g2b-contract-demand-radar' by specifying EU TED 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?

The description provides clear context on what the tool does and its scope (EU public-sector tenders), which implies when it should be used. It does not explicitly name alternatives or exclusions, but the scope is sufficiently specific for an AI agent to infer appropriate use cases.

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

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

Annotations already cover read-only safety (readOnlyHint=true, destructiveHint=false). The description adds useful behavioral context beyond that: it promises live data, no auth or browser needed, and discloses the per-call cost ($0.02/call). This is meaningful added value without contradicting any annotations.

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

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

The description is two sentences, front-loaded with the core action and resource, followed by concise practical notes. Every clause adds value; the pricing sentence is brief and does not distract from the primary purpose.

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 listing-pulling tool with rich annotations and a fully described 5-parameter schema, the description covers the essential context: source, location, filters, non-authenticated access, and cost. It does not describe the return format in detail, but the absence of an output schema is mitigated by the straightforward 'listings' concept and the schema's reference to 'listing rows'.

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 every parameter has a clear description (city path, deal_type enums, etc.). The description only restates the filter categories ('by deal type, property type and city') without adding novel semantic details, so it stays at the baseline for fully described schemas.

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 ('Pull') with a clear resource ('live apartment and house listings straight from Imovirtual.com') and specifies the filtering dimensions (deal type, property type, city). It unambiguously identifies the Portuguese real-estate domain, distinguishing it from country-specific sibling tools.

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

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

The description gives clear context: it is for Imovirtual.com listings in Portugal, and states practical benefits ('No login, no browser, no proxies') that help decide when to use it. It does not explicitly name alternatives or exclusions, but the Portugal-specific scope is immediately evident from the text and sibling context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false; the description adds valuable context: it is free, requires no auth, uses official SEC EDGAR data, and costs $0.01/call. Rate limits are mentioned in the schema rather than 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?

The description is a single, information-dense sentence that front-loads the core purpose. Pricing and payment details are relevant for a paid tool, though the x402 payment method is slightly tangential.

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

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

With no output schema, the description provides a concise summary of return values (filing counts, activity signal, document links per company). It covers the key aspects without needing to detail every field.

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?

All three parameters have full schema descriptions, so the schema carries the semantic load. The description adds no additional parameter-specific 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?

Description clearly states the tool tracks insider stock trades from SEC Form 3/4/5 filings for any list of tickers, and summarizes outputs. However, it does not explicitly differentiate from sibling tools like sec-edgar-watcher or thirteen-f-tracker.

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 conveys the intended use case (tracking insider trades for a list of tickers) and mentions key features (free, no API key), but does not explicitly contrast with alternatives or state 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?

The description adds meaningful behavioral context beyond annotations: it discloses that the first run creates a baseline and that the tool says so, and it includes the cost per call. While it doesn't detail all stateful mechanics, the added value is solid given annotations already flag non-read-only and open-world aspects.

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 exceptionally concise and front-loaded: two sentences cover the core behavior and baseline mechanism, plus a short pricing note. Every segment adds necessary context, with no filler or redundant repetition of schema fields.

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

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

For a stateful watcher with no output schema, the description covers the essential behavior, first-run baseline, and cost. It could specify the return format or how to reset a baseline, but the input schema's per-parameter details and README references fill most 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?

All four parameters have thorough descriptions in the input schema, so the schema carries the full semantic weight. The tool description doesn't mention parameters, but with 100% schema coverage, no additional information is needed. Baseline 3 is appropriate.

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

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

The description clearly states what the tool does: it 'watches a job board for a saved filter' and 'returns only the postings that appeared since the previous check.' This specific verb + resource + scope distinguishes it from the many sibling scrapers and aggregators, which don't offer baseline-based incremental monitoring.

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

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

The description clearly implies when to use this tool: when you want to monitor a job board for new postings since the last check. The 'previous check' and 'first run' language provides strong contextual guidance, though it doesn't explicitly name alternative tools or exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds valuable behavioral detail: 'No login, no scraping, no proxies' clarifies the safe, authorized nature of the operation, while the normalization clause ('title, location, department, URL, posted date') discloses exactly what the returned rows contain. Pricing and payment method are also disclosed. No contradiction with annotations.

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

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

Two sentences cover the core purpose, output format, operational guarantees, and pricing. It is front-loaded with the action verb and resource, and every clause earns its place—no filler or redundancy.

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

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

For a simple tool with 2 parameters and no output schema, the description is complete: it lists output fields, explicitly covers the no-login/no-scraping behavior, and even includes pricing. It tells the agent everything needed to invoke and interpret results without external discovery.

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 both parameters (items format and maxConcurrency semantics). The description adds some context (e.g., mentioning Greenhouse/Lever/Ashby aligns with the provider values) but doesn't substantially augment parameter meaning beyond the schema, warranting the baseline score of 3.

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

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

The description starts with a specific verb 'Pull' and names the resource ('a company's public applicant-tracking system (Greenhouse, Lever, Ashby)') along with the normalization outcome ('one row per posting: title, location, department, URL, posted date'). This clearly differentiates it from sibling tools like property listings or tender alerts, which target different domains.

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 you need all open roles from a company's ATS—and adds differentiating context like 'No login, no scraping, no proxies.' However, it does not explicitly name alternative tools (e.g., 'job-alert', 'jobs-ch-swiss', 'xing-jobs') or provide a when-not-to-use statement, so guidance remains implied rather than explicit.

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

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

Annotations already declare readOnlyHint true and destructiveHint false, and the description adds that listings are public plus cost/payment information. However, it does not disclose pagination behavior, rate limits, or data freshness, though annotations cover the key safety aspects.

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

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

The description is a single, well-structured sentence that covers purpose, scope, and output fields, followed by a succinct pricing note. Every word earns its place with no fluff or redundancy.

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

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

Given the rich parameter schema and annotations, the description adequately covers tool purpose, scope, output fields, and cost. It does not describe rate limits or failure modes, but no output schema exists, so listing the returned fields is especially helpful.

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

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

Schema description coverage is 100%, with detailed explanations for each parameter (e.g., max_pages, fetch_full_description). The description adds no parameter-level detail beyond the schema, 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 uses a specific verb ('Search') and names the exact resource ('jobs.ch (Switzerland)'), listing concrete output fields (title, company, location, employment type, posted date, URL). This clearly distinguishes it from sibling tools like job-postings-aggregator or xing-jobs.

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 use when searching Swiss jobs on jobs.ch but provides no explicit guidance about when to choose this over alternatives (e.g., job-postings-aggregator, xing-jobs) or when not to use it. No exclusions or alternative tool references are given.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, which the description aligns with. The description adds valuable behavioral context: no login, no browser, no proxies, and the $0.02/call cost with x402 payment. It doesn't contradict the annotations.

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

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

The description is a single focused sentence that conveys purpose, scope, and constraints, followed by a compact note on pricing/payment. Every word earns its place with no redundancy.

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

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

Given the schema fully documents parameters and annotations cover safety, the description adds essential operational context: live data, no auth/browser/proxies, and cost. However, with no output schema, it doesn't describe the return structure, which would further help the agent.

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 documents all four parameters with descriptions and examples, achieving 100% schema_description_coverage. The tool description only restates 'by deal type, property type and city' which is already in the schema, adding no additional semantic value beyond the baseline.

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

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

The description clearly states the action ('Pull live apartment and house listings') and the specific resource (Krisha.kz, Kazakhstan's real-estate classifieds portal), and explicitly names the filtering dimensions (deal type, property type, city). This distinguishes it from sibling real-estate tools like otodom-warsaw or rightmove-london.

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 provides clear context for when to use the tool: it's for Kazakhstan listings, with 'No login, no browser, no proxies' and a price. It doesn't explicitly name alternatives or state when not to use it, but the Kazakhstan focus and portal name imply the intended use case.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description discloses critical behavioral traits: keyless access, no wallet/RPC requirement, reliance on DexScreener's public API, and a cost of $0.01/call via x402 (USDC on base). This cost and payment mechanism are essential for an agent to know before invoking, providing significant added value.

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 concise and front-loaded with the core purpose, followed by key operational and cost details. Every clause serves a purpose—purpose, data fields, access requirements, and pricing—without unnecessary fluff.

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

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

For a simple price oracle with no output schema, the description covers the essential context: what data is returned, how to access it (public API, keyless), cost, and use case. It is complete for an agent to decide invocation and understand the response envelope.

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. The description does not add meaning beyond what is in the schema (e.g., 'contract address or ticker' is already in the tokens parameter description). It does clarify the output includes 'best DEX pair', but that is output semantics, not parameter semantics.

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 function: 'Current USD price for any token by contract address or ticker' and lists the included data fields (24h change, liquidity, volume, best DEX pair). This is a specific verb+resource definition that distinguishes it from sibling tools like rug-pull-scorer or token-launch-radar.

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

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

The description provides clear usage context: 'Built to be called cheaply by AI agents that just need the number' implies when to use it (simple price lookups) and hints at when not to (when richer data or on-chain access is needed). It does not explicitly name alternatives, so it misses a point for exclusion 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?

The description adds meaningful context beyond annotations: it discloses a $0.02/call cost and x402 (USDC on base), and states the actor is unofficial and independent. The schema description adds that titles are matched deterministically and only selected documents are validated. This complements the annotations (readOnlyHint=false, idempotentHint=false) without contradiction.

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

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

The description is concise, containing three distinct segments: purpose, independence disclaimer, and cost. Each adds value and the purpose is front-loaded. The first sentence could be more precise, but overall it is well-structured and free of 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?

There is no output schema, so the description should indicate what the tool returns, but 'action evidence' is vague and no result structure is described. While parameter details are well-covered by the schema, the overall behavior and return format are insufficiently explained for an agent to fully anticipate the outcome.

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?

All 7 parameters have descriptions in the input schema (coverage 100%), so the schema provides the necessary meaning. The main description does not add parameter-level details, and the baseline for high schema coverage is 3. No extra value is contributed by 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 'Turn today’s allowed official publications into watchlist-linked action evidence' identifies a specific transformation and resource, and clearly differentiates from sibling tools focused on jobs or real estate. The phrase is slightly metaphorical, but the schema description 'Matches customer watch rules against one official Turkish Gazette issue' adds precision. The tool's purpose is clear enough for selection.

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 explicit guidance on when to use this tool versus alternatives. It mentions 'today’s allowed official publications' which implies daily use, but there are no exclusions or reference to sibling tools. An agent must infer the use case primarily from the tool name.

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

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

Annotations already declare read-only and non-destructive hints. The description adds useful behavioral context: no login/browser/proxies, live data, and a per-call cost including payment method, which is beyond the annotation coverage.

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 function, followed by access and cost details. Every sentence adds value, with no redundancy or filler.

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

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

Given a 5-parameter tool with no output schema, the description sufficiently explains access, cost, and filtering dimensions. Missing details like return format are partly covered by the schema, and the tool is simple enough to be adequately described in this length.

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 parameters are already well documented. The description reiterates city, deal type, and property type but adds no new semantics beyond the schema, meeting the baseline for high coverage.

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

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

The description clearly states the tool pulls live apartment and house listings from Otodom.pl, filtered by deal type, property type, and city. This specific verb+resource+scope distinguishes it from sibling real-estate tools focusing on other regions.

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?

Mentions Poland's biggest portal and the ability to filter by city, implicitly indicating use for Polish listings. No explicit exclusions or alternatives, but the regional focus is clear enough for selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds useful context: it is free, returns pricing/payTo/network details, and serves as a first-step info tool. This goes beyond the annotation baseline without contradicting it.

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

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

A single, front-loaded sentence conveys everything: 'Free — ' set apart, then the action and information returned, followed by a usage trigger. Every clause earns its place with no redundancy.

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

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

For a simple, no-parameter informational tool, the description fully covers purpose, content (price, payTo, network), and when to call. No output schema exists, so the description appropriately carries the meaning without needing extra detail.

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

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

The tool has zero parameters, so there is no parameter burden. The descriptive text adds no parameter info, but with 0 params and 100% schema coverage, a baseline of 4 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 function: listing every paid tool in the 'market-data' bundle with price, payTo address, and network. This specific verb-resource pair ('list every paid tool') distinguishes it from the many other data-feed sibling tools.

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

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

The phrase 'Call this first if you don't have a wallet ready yet' provides explicit when-to-use guidance, indicating this is a preliminary step for users without a wallet. However, it does not explicitly name alternatives or state when not to use it, so it falls slightly 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?

Beyond the readOnlyHint and destructiveHint annotations, the description adds valuable behavioral context: no authentication needed, no browser scraping, no proxy requirements, results sorted freshest-first, and a per-call cost. This gives the agent a clear picture of the tool's operational characteristics without needing to inspect the implementation.

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 well-structured: the first sentence states the core function, the second covers access simplicity, and the final clause provides cost. Each element carries useful information without redundancy, front-loading the primary action.

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

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

Given the moderate parameter count and rich schema, the description covers the essential context: what data is returned, from where, how fresh it is, and access prerequisites. However, without an output schema, it doesn't describe the structure of returned listings (e.g., fields like price, location, URL). This is a modest gap, but the description still provides enough for an agent to make an informed 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 100%, and each parameter already has a detailed description (e.g., emirate's explanation about sitemap pages, max_items meaning with max_listing_age_days). The main description adds no additional parameter information, 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 clearly identifies the action ('Pull live apartment, villa, penthouse and townhouse listings'), the specific source (PropertyFinder.ae, the UAE's biggest real-estate portal), and the filtering dimensions (deal type and emirate). This distinguishes it from sibling listing tools by naming the exact portal and property types.

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: to fetch live UAE property listings from PropertyFinder.ae, with filtering by deal type and emirate. It doesn't explicitly name alternatives or exclusions, but the niche scope and mention of 'No login, no browser, no proxies' implicitly guide usage. A brief comparison to sibling real-estate tools would elevate it to a 5.

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

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

Annotations already declare read-only and non-destructive behavior. The description adds useful context beyond that: live listings, no authentication required, and a $0.02/call pricing model. No contradictions found.

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: the first delivers the core function and scope, the second adds operational extras (no auth, pricing). Every clause contributes information, and the key verb appears first.

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

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

Given the rich schema and the absence of an output schema, the description covers the functional purpose, geographic scope, and access constraints well. It does not describe the listing output fields, but that is not strictly required for tool selection and 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 provides 100% coverage with descriptions for all five parameters, so the schema itself carries the semantic load. The description only restates the three key filters without adding extra parameter-level detail or examples.

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 ('Pull') with a clear resource (Realitica.com listings) and geographic scope (Montenegro, Croatia, Serbia), making it easily distinguishable from sibling real-estate tools. It also mentions the three key filtering dimensions, fully covering the tool's purpose.

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

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

The description provides clear context about the geographic area and access method ('No login, no browser, no proxies'), but it does not explicitly name alternatives or state when not to use the tool. This is adequate for selection among siblings given the unique resource name and geography.

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

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

Annotations provide basic flags (readOnlyHint=false, openWorldHint=true, etc.), but the description adds valuable behavioral context: it maintains a baseline across runs, first run creates the baseline and says so, and there is a cost per call (USDC on base). These details go beyond the schema and annotations, making the tool's operational semantics clearer.

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 concise: two sentences plus a cost note. It front-loads the core purpose (watch and return new listings) and adds the critical baseline behavior without unnecessary verbosity.

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 (stateful baseline, multiple portals, nested filter object) and no output schema, the description adequately covers the most important behavioral aspects: baseline creation, incremental results, and cost. It does not detail return format, but the schema covers input specifics, so the description is reasonably 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 input schema has 100% description coverage for all four parameters, so the description doesn't need to compensate. The tool description adds no extra parameter-level meaning beyond what the schema already provides, and it doesn't explain the filter JSON structure or portal-specific fields.

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

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

The description clearly states a specific action: watches a property portal for a saved filter and returns only new listings since the previous check. This distinguishes it from sibling alert tools by explicitly focusing on property portals and incremental listing retrieval.

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 getting new listings on property portals since last check) and explains first-run baseline behavior, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. Sibling tools like job-alert or tender-alert are not referenced.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, aligning with the read-oriented 'Pull live' description. It adds meaningful context beyond annotations by stating 'No login, no browser, no proxies', which clarifies access/execution behavior, and 'live' indicates real-time data. No contradiction with annotations.

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

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

The description is one well-structured sentence that front-loads the core function and includes supporting details in an efficient manner. The pricing and access clarifications are brief and useful, with no redundant or filler language.

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

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

For a simple read-only listing tool, the description combined with full schema coverage covers the essential context: source, scope, deal types, and output limits. No output schema exists, but the description does not describe return value structure; still, the tool's behavior is sufficiently clear for typical use.

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?

Schemas provide 100% coverage for all four parameters (deal_type, max_items, max_pages, location_identifier), so the description does not carry the burden. The description reinforces the location_identifier flexibility ('London or any other Rightmove location code') but does not add new parameter-specific 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 clearly states the tool pulls live for-sale and to-rent property listings from Rightmove.co.uk, specifying the source (UK's biggest property portal) and scope (London or any Rightmove location code). This distinguishes it from siblings by naming the exact platform and geographies, leaving no ambiguity about its function.

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 implicitly communicates when to use the tool: when live Rightmove UK property listings are needed, for London or any location code. However, it does not explicitly mention alternatives or exclusions (e.g., 'use this instead of other national tools'), though the source name and location handling make usage context clear.

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

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

Annotations already provide readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds valuable context: it is a heuristic signal, no wallet/RPC/browser required, uses specific data sources, and costs $0.01/call. This goes beyond the annotations by disclosing the tool's operational characteristics and limitations.

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

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

The description is a single, information-dense paragraph with no wasted words. It front-loads the main purpose and then efficiently lists detections, disclaimers, and cost. Every sentence adds unique value, making it both concise and structured.

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 only 3 parameters and no output schema, the description is remarkably complete. It covers purpose, data sources, detection capabilities, heuristic nature, constraints (no wallet/RPC/browser), and pricing. No critical context is missing for an agent to decide on and invoke the 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%, with detailed descriptions for tokens, chainId, and maxConcurrency. The tool description itself does not add parameter-specific meaning beyond the schema, so the baseline of 3 is appropriate given the schema's thoroughness.

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 function: 'Score ERC-20/BEP-20 token rug-pull risk from honeypot.is simulation + DexScreener liquidity/age.' It also enumerates specific detections (honeypots, high taxes, thin liquidity, brand-new pairs), distinguishing it from sibling tools like token-launch-radar or live-price-oracle.

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

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

The description implies usage context (heuristic risk assessment, not financial advice) but does not explicitly state when to use this tool versus alternatives. It mentions 'Heuristic signal, not financial advice' which guides interpretation, but no direct exclusions or sibling comparisons. This is adequate but not explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context: official data source, no API key/login required, output includes form/filing date/direct URL, and a per-call price. This complements rather than contradicts the annotations.

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

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

Three tight sentences plus a price tag. Each clause adds value: purpose, source/auth, filtering/output, and cost. No redundancy or fluff.

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

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

With 4 parameters and no output schema, the description covers purpose, source, output fields (form, filing date, direct URL), and constraints (lookback, filter). Combined with the schema's per-parameter details, it is sufficient for an agent to invoke and interpret results. Minor omissions like result ordering or empty-result behavior are not critical.

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

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

Schema coverage is 100% with every parameter described, so the baseline is 3. The description mentions 'Filter by form type and lookback window' (mapping to formTypes and sinceDays) but adds no new semantic details 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 uses a specific verb ('Watch') with a clear resource ('stock tickers for new SEC filings'), enumerates form types (10-K, 10-Q, 8-K, S-1), and notes the official SEC EDGAR source. It clearly distinguishes itself from sibling tools like live-price-oracle or insider-trading-tracker by focusing on 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?

It provides clear context for when to use: monitoring SEC filings, with free no-login access and filtering by form type and lookback window. It does not explicitly name alternative tools to avoid, but the domain is so sharply defined that usage is unambiguous.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by disclosing that no login, browser, or proxies are required, and by providing cost information ($0.02/call). These are useful behavioral traits beyond the annotations, and there is no contradiction.

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

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

The description is only two sentences, front-loaded with the core action ('Pull live real-estate listings straight from SS.ge'), and includes essential caveats (currency, no auth, cost). Every sentence contributes useful information with no filler.

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

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

Given the tool's simplicity and the rich schema/annotations, the description provides sufficient context: source, scope, currency behavior, access requirements, and cost. It does not detail output fields, but the absence of an output schema and the straightforward nature of a listing pull make this acceptable. The description complements the structured data well.

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 provides 100% parameter coverage with rich descriptions, including known city IDs and deal_type behavior. The description itself only mentions 'by city' and currency, which adds no meaningful parameter-level detail beyond what the schema already documents. Thus, the schema does the heavy lifting, and the description is not required to compensate.

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 function with a specific verb ('Pull') and resource ('live real-estate listings straight from SS.ge'). It also distinguishes itself from sibling tools by naming the unique portal (SS.ge) and geographic focus (Georgia), and adds a specific detail about currency (GEL or USD) as set by the seller.

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

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

The description provides clear context for when to use this tool: when a user needs live real-estate listings from Georgia's SS.ge portal, organized by city. It does not explicitly name alternatives or state exclusions, but the country and portal are unambiguous, which is sufficient to guide an agent among many similar 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: it emphasizes 'live' data, the lack of login/browser/proxies (server-side fetch), and a transparent cost of '$0.02/call' with payment method. This goes beyond the annotations and helps the agent anticipate operational characteristics.

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 crisp sentences: the first states the core function, the second covers key operational benefits and cost. Every clause earns its place, with no filler. The most important information is front-loaded, and the structure makes it 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?

The description covers the 'what', 'where', and high-level operational details, but there is no output schema, so the agent is left without guidance on the structure of the returned listings (e.g., fields, pagination, item limits). While the input schema is thorough, the lack of any return-value description or mention of pagination behavior is a notable gap for a tool that agents will call programmatically.

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 mentions filtering by 'deal type, property type and city', which aligns with the schema's parameters, but adds no new parameter-level meaning (e.g., format hints, interactions, or edge cases). It does not alter or enrich what the schema already says.

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 ('Pull live apartment and house listings') and a specific resource ('Storia.ro, Romania's biggest real-estate classifieds portal'), making the tool's purpose unambiguous. It explicitly mentions filtering by deal type, property type, and city, which distinguishes it from sibling tools covering other countries or domains.

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

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

The description clearly implies when to use this tool (for Romanian real-estate listings) and highlights benefits like 'No login, no browser, no proxies' and low cost. However, it does not explicitly contrast it with alternatives like otodom-warsaw or rightmove-london, nor does it state when not to use it. The context is clear but lacks direct exclusions.

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

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

Annotations already declare read-only and non-destructive behavior; the description adds valuable context: 'No login, no browser, no proxies' clarifies auth/infrastructure requirements, and pricing is disclosed. It does not detail rate limits or query behavior, but annotations cover the safety profile.

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: one principal sentence covering purpose and source, plus a brief note on technical requirements and pricing. Every clause adds distinct value with no redundancy.

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

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

For a simple 3-parameter list-fetcher with full schema coverage and safety annotations, the description provides adequate context including pricing and auth. It omits explicit return format, but the absence of an output schema lowers the expectation, and the tool's purpose is straightforward.

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 documents all three parameters thoroughly. The description adds only general mention of 'by real-estate category' and 'apartment listings', which does not enhance parameter understanding 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?

Description opens with a specific verb 'Pull' and names the exact resource 'live apartment listings straight from Tap.az', clearly differentiating it from sibling real-estate tools like emlakjet-istanbul or krisha-kz by marketplace and geography. The phrase 'Azerbaijan's biggest classifieds marketplace' anchors the tool's domain.

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

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

Usage context is implied by naming Tap.az and Azerbaijan, but no explicit alternatives or when-to-use guidance are given. The only usage caveat is in the schema description noting that 'menziller' is the only verified category, which is not highlighted in the main 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?

Even with annotations indicating non-read-only and open world, the description adds valuable context: the first run creates a baseline, only changes are returned, and the pricing ($0.05/call). This explains stateful behavior and cost beyond what annotations or schema provide.

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

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

Two sentences plus a cost note. Every sentence earns its place: the first explains core functionality and output, the second addresses first-run behavior, and the cost line adds critical operational info. 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 description is complete for a stateful change-monitoring tool. It explains the type of results (new tenders, closed ones, changed deadlines), the baseline creation on first run, and pricing. Although there is no output schema, the description adequately conveys what to expect.

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

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

The input schema has 100% description coverage for all 5 parameters, so the schema carries the full semantic burden. The tool description does not add parameter-specific meaning beyond mentioning 'saved filter' conceptually, which is already covered by the query parameter 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 it 'Watches public tender feeds for a saved filter and returns only what changed since the previous check' — a specific verb, resource, and unique focus on deltas. This distinguishes it from sibling search tools like gov-tender-radar by emphasizing change detection rather than initial search.

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

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

The description implies the tool is for ongoing monitoring ('returns only what changed since the previous check' and first-run baseline behavior) and is distinct from a one-time search. However, it does not explicitly name alternatives or state when not to use it, so it lacks explicit exclusions.

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

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

Annotations already declare read-only and non-destructive behavior, and the description adds useful context: official SEC data, free, no auth, and a cost of $0.01/call paid in USDC. It also discloses the output fields (form, filing date, accession number, link), which is behaviorally informative beyond the annotation-only safety profile.

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

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

The description is a single, information-dense sentence followed by a concise cost/format note. It front-loads the core functionality and avoids redundant elaboration, earning every word.

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

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

With no output schema, the description explains the return payload (form, filing date, accession number, EDGAR link), data source, authentication, and cost. It omits some operational details like pagination or rate-limit enforcement, but for a simple read-only tracker this is adequate.

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 covers 100% of parameters with detailed descriptions (e.g., managers can be CIK/name, sinceDays limits, maxConcurrency rate limit). The description itself adds no parameter-specific detail beyond mentioning CIK/name lookup, so it stays at the baseline of 3.

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

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

The description names a specific verb ('Track') and resource ('institutional managers' 13F-HR filings'), and clearly identifies the returned data (form, filing date, accession number, EDGAR link). It distinguishes itself from siblings like insider-trading-tracker and sec-edgar-watcher by focusing on 13F quarterly 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 implies the tool is for tracking institutional managers via CIK/name and getting recent 13F filings, and it adds 'Official SEC data, free, no API key or login'. However, it does not explicitly state when to use this tool over sibling alternatives like sec-edgar-watcher, nor does it mention exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context beyond this: it is 'Powered by DexScreener's public API,' requires 'No key, no wallet, no on-chain node,' and mentions a cost of '$0.01/call, x402 (USDC on base).' This tells the agent about dependencies, auth requirements, and financial costs, which is useful for invocation decisions.

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 plus a pricing note, each part earning its place. The core functionality is front-loaded, followed by operational details (API, no auth, cost). No fluff or redundancy; it is appropriately sized for the tool's complexity.

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

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

For a read-only lookup tool with 4 parameters and no output schema, the description covers the essentials: purpose, data source, authentication, cost, and the key output metrics. It does not describe error handling or response format, but the output fields are already listed. This is adequate given the tool's simplicity and the rich parameter 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 input schema has 100% description coverage, with each parameter clearly described (tokens, maxAgeHours, maxConcurrency, minLiquidityUsd). The description itself does not add semantic detail to these parameters; it only mentions output fields, not input filtering options. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description clearly states the tool's function: 'Look up any token contract address or ticker across DEXes and get liquidity, 24h volume, pair age, a 0-100 quality score and risk flags.' This provides a specific verb (look up), a resource (tokens across DEXes), and the exact output metrics. It distinguishes itself from siblings by emphasizing DEX coverage and the quality score/risk flags.

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 you need token data across DEXes. It does not explicitly mention alternatives or exclusions, but the phrase 'across DEXes' implies it is not for CEX data. No direct comparison to siblings like rug-pull-scorer or live-price-oracle, so it misses the 'when-not-to-use' differentiation that would earn a 5.

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

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

Annotations only provide generic hints (readOnlyHint false, openWorldHint true), but the description and schema add rich behavioral detail: per-call cost, stateful 'since last check' logic, first-run baseline behavior, rate-limit handling, and honest partial coverage. This far exceeds what annotations offer and gives the agent clear 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?

The description is a single, focused sentence that front-loads the tool's purpose, followed by a concise cost note. No wasted words; it 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?

Despite 9 parameters and no output schema, the schema descriptions comprehensively cover edge cases, billing, and behavior. The only minor gap is a lack of explicit output row format, but the description's 'get only the new ones' plus parameter context make the tool's intent complete enough.

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

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

Schema description coverage is 100% with highly detailed parameter descriptions, so the baseline is 3. The main description adds only a high-level summary of filter types ('keywords, CPV codes, value threshold or region') and does not add new syntax or edge-case 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 clearly states a specific action ('Watch UK Find a Tender') and resource, plus an incremental filtering behavior ('newly matching... since your last check'). This distinguishes it from sibling tools like generic tender-alert or gov-tender-radar by specifying the UK source and stateful lead-alert 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 description implies a monitoring use case for new UK public tenders, and the schema enforces that at least one filter is required, which is clear usage context. However, no explicit alternatives or when-not-to-use guidance are given, so it misses the full 'when vs alternatives' standard.

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

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

Annotations already declare readOnlyHint=true, but the description adds valuable behavior beyond that: it requires the user's own Etherscan key ('BYOK Etherscan (your key, your quota)'), specifies a cost per call ('$0.01/call, x402'), and clarifies the output is a heuristic signal ('Not a guarantee of eligibility'). These are important operational details not present in annotations.

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

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

The description is a single, compact sentence (~30 words) that front-loads the core action and result, then efficiently adds critical caveats (heuristic, cost, key usage). No wasted words; 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?

With no output schema, the description appropriately explains the return value ('0-100 airdrop-farming readiness score') and covers key operational constraints (cost, BYOK, heuristic). The schema handles parameter details, so the description is complete for a read-only tool with this 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 input schema has 100% parameter description coverage, so the schema fully documents each parameter. The description adds general context about score criteria (age, tx activity, etc.) but does not introduce new meaning for individual parameters 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 uses a specific verb 'Profile a wallet on-chain' and clearly states the output: 'a 0-100 airdrop-farming readiness score'. It lists the exact wallet attributes used (age, tx activity, contract & token diversity), which distinguishes it from sibling tools like rug-pull-scorer or whale-wallet-tracker.

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

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

The description implies when to use the tool: to profile a wallet for airdrop-farming readiness. It provides context by noting the heuristic nature and BYOK requirement, but it does not explicitly state alternatives or exclusions relative to sibling tools. No explicit 'when-not-to-use' guidance is given, but the purpose is clear enough.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds important context beyond that: it requires a bring-your-own-key API approach, costs $0.01/call via x402, and outputs one row per wallet. It also clarifies that no browser or RPC node is needed, which helps set expectations. However, it does not detail rate limits or potential error conditions, but the annotation coverage lowers the burden.

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: the first sentence states the core function and method, the second lists key outputs, and the third clarifies non-requirements and cost. Every sentence adds value, and the key information is front-loaded in the first sentence.

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

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

Given the tool has 5 parameters, no output schema, and substantial annotations, the description is fairly complete for a tracker tool. It covers the data sources, output granularity, API key requirement, and pricing. It does not explain the exact response structure in detail, but the description's mention of 'balance, flagged transfers, and recent token activity' gives a reasonable preview. The lack of a formal output schema is mitigated by the clear output hints in the description.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does add some semantic value by linking 'flagged transfers above your ETH threshold' to minValueEth and mentioning 'one row per wallet' for the wallets parameter, but it largely restates concepts already in the schema. It does not provide deep additional parameter-level detail beyond that.

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's purpose: to track large native ETH and ERC-20 token movements for any wallet(s) via Etherscan's multichain API. It specifies the key actions (get current balance, flagged transfers, recent token activity) and distinguishes itself from siblings like wallet-airdrop-profile by focusing on movement tracking rather than profile analysis.

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

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

The description provides clear context on when to use the tool: for large token movement tracking with no RPC node, wallet-connect, or browser needed. It implicitly differentiates from alternatives by highlighting its simplicity and API-based approach, though it does not explicitly name sibling alternatives or state when not to use the tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral details: no login/browser/proxies required, and per-call pricing. It does not describe rate limits or output format, but the added access/cost context goes beyond annotations.

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

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

The description is two short, information-dense sentences. It front-loads the action and source, then adds access and pricing in a compact suffix. 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?

With no output schema, the description doesn't explain the shape or fields of the returned listing data. While the source and deal types are clear, and schema covers inputs, an agent may need to infer what each 'listing' contains or how results are paginated.

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

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

Schema coverage is 100% with detailed descriptions for all four parameters, including enum titles and city slug caveats. The description only restates 'rental and sale' which already matches the deal_type enum, so it adds no meaningful parameter-level semantics 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 pulls live apartment rental and sale listings from Willhaben.at for Vienna, using a specific verb ('Pull') and exact resource. It distinguishes itself from sibling tools by the portal and city 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?

The description provides clear context: this is for Vienna real estate listings on Willhaben. It does not explicitly mention alternatives or when-not-to-use, but the geographic and portal specificity makes the intended use obvious.

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

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

Annotations already mark it as read-only and non-destructive, but the description adds meaningful context: it walks the sitemap, visits each job page, handles HTTP 410 churn by compensating with extra candidates, and discloses the cost per call. This goes well beyond the annotations.

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

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

The description is a single, information-dense sentence that front-loads the action and includes essential details (fields, method, cost) without any redundant words. Every part adds value.

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

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

With no output schema, the description lists all returned fields, explains the crawling mechanism, and describes fault behavior (410 churn and compensation). This is fully sufficient for an agent to understand the tool's scope and behavior.

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

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

Input schema covers 100% of parameters with detailed descriptions, so the baseline is 3. The tool description adds minimal parameter-specific meaning (e.g., optional full description aligns with fetch_full_description) but does not extend beyond the schema's own richness.

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

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

The description clearly states it walks xing.com's job sitemap and pulls public job listings from Germany/Austria/Switzerland, with a specific verb and resource. It also lists fields returned, distinguishing it from sibling job scrapers by site and region.

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

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

The description provides clear context for when to use the tool (scraping XING DACH jobs) but does not explicitly mention alternatives or exclusions. It is easy to infer when to use it, though it lacks explicit 'when not to use' guidance.

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