terminalfeed

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

Annotations already indicate readOnly, openWorld, and idempotent behavior. The description adds valuable context: data sources (GitHub Advisory Database plus vendor advisories), licensing (CC BY 4.0), and the credit cost for premium access. It does not contradict annotations and provides provenance and potential cost implications.

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 moderately long but each sentence adds substantive info: what the pulse includes, the premium upgrade path, and the data source/license. It is front-loaded with the main output. Minor redundancy exists ('CVE pulse' + 'filtered to the AI stack' is slightly repetitive), but overall it is compact and well-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?

With no output schema, the description must explain return values and it does enumerate the key fields. It also mentions the premium data source and licensing. However, it does not specify the exact response format, pagination, or how to access the premium list beyond stating the credit cost, leaving a small gap for an agent needing precise invocation details.

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

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

The tool has zero parameters and schema coverage is 100% (empty schema covers all). The description compensates by explaining what the output contains, effectively serving as parameter/return documentation. It goes beyond the baseline for zero-parameter tools by detailing the exact result 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 uses a specific, informative phrase 'Current AI-software-stack CVE pulse' and enumerates the exact outputs (total advisories, exploited-in-the-wild count, severity/category breakdown, top CVE headline). It clearly distinguishes from sibling tools by scoping to the AI stack and listing specific categories, 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 states the tool's scope (AI stack only) and what it provides, implying use when AI-stack CVE awareness is needed. It also notes that the full per-CVE list is premium, guiding users who need deeper detail to a paid option. No explicit alternatives are named, but sibling tools are topically distinct, reducing ambiguity.

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

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

Annotations already declare readOnly, openWorld, and idempotent hints. The description adds concrete behavioral context: 'No auth required', 'Cache TTL 60s', and 'Returns JSON'. This goes beyond the annotations and helps the agent understand side effects and performance 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 compact and front-loaded: purpose, return type, auth/cache details, and usage context. Every sentence adds value, with no redundant or vague wording.

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 no-parameter tool with no output schema, the description is sufficiently complete. It lists all the data sources included in the snapshot, states the return format, clarifies auth and caching, and provides usage guidance. The agent can confidently decide when and how to invoke it.

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

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

With zero parameters, the schema fully covers the parameter space. The description rightly focuses on output and behavior instead. The baseline of 4 is appropriate since there are no parameter semantics to explain.

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 ('Fetches') and clearly identifies the resource as a 'real-time world-state snapshot', then lists its components (BTC ticker, Fear and Greed Index, earthquakes, HN story count, ISS crew). This distinguishes it from sibling tools that focus on single data sources.

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

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

The description explicitly states when to use: 'Use when the agent needs a quick global pulse before deciding what to investigate.' This gives clear context, though it does not name specific alternatives or exclusions, so it stops short of a 5.

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

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

The annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description goes beyond by disclosing the source (Binance with CoinCap fallback), cache TTL (15s), and that no auth is required. These are useful behavioral traits that help the agent understand freshness and reliability, exceeding the baseline set by 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 three sentences long, each earning its place. The first sentence states the core purpose, the second adds source and caching details, and the third provides use cases. There is no wasted text, and the most important 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?

For a simple, parameterless tool, the description is complete. It explains what data is returned (price, 24h change, high, low, volume), where it comes from, how fresh it is, and when to use it. Without an output schema, the description fills that gap well by listing the expected fields.

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 the input schema is an empty object. The description still adds value by listing the output fields (24h change, high, low, volume), which serves as implicit return-value documentation. Since there are no parameters to describe, 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 starts with a specific verb 'Fetches' and identifies the resource as 'current Bitcoin price in USD' with the exact data points (24h change, high, low, volume). It also names the data source and fallback, clearly distinguishing this tool from the broader crypto-related siblings like tf_crypto_movers.

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 explicit use cases: 'Use for crypto trading decisions or when the agent needs a fresh BTC quote.' It does not mention when not to use or name alternatives, but the context is clear and the tool is highly specialized, so a minor deduction 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 readOnly, openWorld, and idempotent. Description adds cache TTL scaling behavior, return field list, and public domain status. These are valuable behavioral details beyond annotations, though it doesn't cover all potential behaviors like 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?

Five dense sentences, each adding value: purpose, return format, cache behavior, licensing, and usage guidance. Front-loaded with the core action, no redundant text.

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

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

For a simple read-only feed tool with no output schema, the description provides return field names, cache TTL, licensing, and usage context. It's complete enough for an agent to select and invoke correctly.

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

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

Input schema covers both parameters with descriptions of allowed values and defaults (100% coverage). Description reiterates the allowed values but adds no new semantic information beyond the schema, so baseline 3 applies.

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

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

Specifically states it fetches USGS pre-built summary feeds with selectable magnitude and period. Explicitly distinguishes from sibling tf_earthquakes by mentioning 'more granular control', making its purpose unique.

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 explicit usage guidance: 'Use when the agent needs more granular control than tf_earthquakes.' This indicates when to choose this tool over an alternative.

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

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

Beyond the readOnly/openWorld/idempotent annotations, the description adds valuable behavioral details: '60s cache,' 'US Government public domain,' 'US-only coverage,' and the list of returned fields. This transparently discloses data source, caching, and geographic scope, with no contradiction to 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: purpose first, then return fields, then cache/coverage, and finally use case. Every sentence adds value, especially the return field list which is necessary given no output schema. 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?

For a tool with 6 optional parameters and no output schema, the description covers all essential aspects: filters, return fields, caching, geographic limitation, and use case. It is self-sufficient for an agent to decide when and how to use it, and it complements the schema and annotations 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?

Schema coverage is 100% (all 6 parameters have descriptions), so the baseline is 3. The description largely echoes the schema (e.g., '2-letter state code,' 'exact NWS event name') without adding meaningful extra semantics beyond summarization. It doesn't elaborate on interplay or edge cases.

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 'Fetches active alerts from api.weather.gov' with specific filters (area, event, severity, urgency, status), making the tool's function unambiguous and distinct from sibling climate tools like earthquakes. It also lists the exact return fields, reinforcing 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?

Provides clear context for when to use it: 'Use for situational awareness on active weather hazards.' This gives a strong usage context, though it does not explicitly mention when not to use it or alternatives. Since it doesn't exclude any alternatives, it falls just short of a 5.

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

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

Annotations already declare readOnly, openWorld, and idempotent hints. The description adds valuable context beyond annotations: data source (CoinGecko/CoinLore), cache TTL (30s), and output contents (price, market cap, percentage move). No contradictions.

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

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

Three concise sentences, front-loaded with purpose and data scope, followed by supported details. Every sentence 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, parameterless read-only tool with no output schema, the description covers purpose, return contents, source, caching, and intended use. It is complete and self-contained.

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?

Tool has zero parameters, so the baseline is 4. The description adds no parameter info, but none is needed; schema coverage is trivially 100%.

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 fetches the top 15 cryptocurrencies sorted by 24h price change, with a specific verb and resource. This distinguishes it from sibling tools like tf_btc_price and tf_fear_greed.

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 explicit usage context: 'Use when the agent needs to surface notable crypto market moves.' While it doesn't name alternative tools or exclusions, the context is clear and actionable.

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, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds valuable context beyond annotations: the cache TTL (2 min), the return structure (count and most recent quake details), and the data source. This gives the agent important expectations about data freshness and output format.

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, with no fluff. The first sentence states the core function, the second provides the usage context. Every word earns its place: magnitude threshold, source, return contents, cache TTL, and use case are all packed efficiently.

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

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

For a zero-parameter, read-only tool with no output schema, the description is complete. It tells the agent what data is fetched (USGS earthquakes ≥2.5), what will be returned (count and most recent details), and the freshness constraint (cache TTL). The tool is simple enough that no further detail is necessary.

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 the description carries no parameter burden. It does explain the output (count and most recent quake details), which is helpful given the lack of an output schema. Baseline for 0 params is 4, and no deductions are needed.

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 ("fetches") and resource ("recent earthquakes magnitude 2.5 or greater from USGS"), clearly stating the tool's scope. It distinguishes itself from siblings like tf_climate_earthquakes by naming the data source and magnitude threshold, making its purpose 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?

Provides explicit when-to-use guidance: "Use for disaster monitoring or when the agent needs current seismic activity." It does not explicitly mention when not to use it or alternative tools, but the context is clear and actionable.

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, openWorldHint, and idempotentHint. The description adds operational transparency with cache TTL (1 hour), which informs data freshness expectations, and notes the source (FRED). This goes beyond the structured annotations 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 two sentences, front-loaded with the tool's purpose, then cache TTL, then usage guidance. Every sentence earns its place 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?

For a simple, read-only tool with no parameters, the description is complete: it lists the data returned, states the use case, provides an alternative for broader needs, and discloses caching behavior. No output schema is needed because the indicators are enumerated.

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 zero parameters, so the baseline is 4. The description adds useful context about the return contents (specific indicators), which compensates for the lack of parameter documentation.

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

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

The description uses a specific verb ('fetches') and resource ('FRED economic indicators') and lists the exact indicators (Fed funds rate, CPI, unemployment rate, GDP growth). It explicitly distinguishes itself from the sibling tf_premium_macro, which covers deeper macro data.

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

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

Provides explicit when-to-use guidance: 'Use when the agent needs current US macro indicators.' It also names the alternative tool for deeper macro needs (treasury yields, forex, commodities, indices). This is clear and actionable.

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 idempotent behavior. The description adds valuable context about the data source (Alternative.me) and cache TTL (5min), going beyond the annotations without contradicting them.

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

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

The description is two sentences, front-loaded with the core function, then source and cache, then usage. Every sentence 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 zero-parameter tool with no output schema, the description fully explains what is returned, the data source, caching behavior, and intended use. Nothing essential is missing.

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

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

The schema has no parameters, so the description carries no parameter burden. It still enriches understanding by detailing the output (index value and classification label), which is useful in the absence of an output 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 it 'Fetches the current Crypto Fear and Greed Index value (0-100) with classification label', using a specific verb and resource. This distinguishes it from sibling tools like price or movers tools.

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

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

It explicitly says 'Use as a sentiment signal for crypto trading decisions', providing clear usage context. However, it does not mention alternatives or when not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is known. The description adds valuable context about the data source (Frankfurter/ECB) and caching behavior (TTL 5min), which helps the agent understand freshness and reliability. 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 two sentences, front-loaded with the main function, and includes additional details (source, TTL, use case) with no redundancy or fluff. Every sentence earns its place and is appropriately sized for a simple tool.

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

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

For a zero-parameter, read-only tool with no output schema, the description is complete. It covers what is fetched, the exact currencies, the source, cache behavior, and intended use. No major information gaps remain.

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 the schema covers 100%. According to the rubric, a baseline of 4 is appropriate for no-parameter tools. The description does not need to explain parameters; it instead provides the currency list, which is output-related but still relevant context. Baseline of 4 is justified.

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 fetches current foreign exchange rates with USD as base, lists the 16 major currencies, and specifies the source. This distinguishes it from sibling tools like tf_btc_price (crypto) and tf_economic_data (broader economics). The verb 'Fetches' is specific and the resource is unambiguous.

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

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

The description ends with 'Use for currency conversion or FX-aware decisions,' providing a clear context for when to use the tool. However, it does not explicitly name alternative tools or state when not to use it, so it lacks explicit exclusions. The guidance is clear but not fully contrasting with siblings.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description adds useful context: 'Cache TTL 12h,' 'Source: hand-curated from upstream leaderboards,' and the insight that benchmark scores vary by harness. These details go beyond the annotations and inform the agent about data freshness and provenance.

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 four sentences long and front-loaded with the main function. It covers purpose, views, source, cache TTL, and usage context without redundancy. It is slightly longer than strictly necessary, but every sentence adds valuable information.

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

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

With only one parameter, no output schema, and strong annotations, the description fully covers all necessary aspects: what the tool does, how to use the view parameter, data source, caching behavior, and when to use it. It is complete for the tool's complexity.

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

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

The schema only says 'Output shape; default raw' for the 'view' parameter. The description substantially expands on this by explaining each enum value: summary, gaps, combined, and raw, with specific outcomes for each. This provides much richer 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 'Returns a snapshot of public agentic-coding benchmark scores' and lists the specific benchmarks (SWE-bench Verified, Terminal-Bench, Aider Polyglot, METR HCAST), which identifies the exact resource. It also differentiates this tool from siblings by focusing on benchmark scores, distinct from price, weather, or payment 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 explicitly says 'Use when the agent needs to recommend a harness/model combo or explain why two agents using the same model perform differently,' providing clear context for when to use. It does not mention exclusions or alternative tools, but this is acceptable given the unique data domain and no close sibling alternatives.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is known. The description adds valuable behavioral context beyond annotations: the data source (huggingface.co/api/models), cache TTL (10min), and the exact item fields returned. This goes beyond a minimal safety declaration.

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

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

The description is three sentences: the first states the core function, the second provides item details and technical context (source, cache), and the third gives a use case. Every sentence adds value, and the most important 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?

For a simple, read-only tool with no parameters and no output schema, the description covers all essential aspects: what is fetched, the sort/filter criteria, the output fields, the data source, caching behavior, and a usage scenario. This is comprehensive for the tool's complexity.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. Per the rubric, 0 parameters warrants a baseline of 4. The description does not need to explain parameters, and the absence of parameters is clear from the schema.

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

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

The description uses a specific verb ('fetches') and clearly identifies the resource ('top 15 trending HuggingFace models') with additional qualifiers ('sorted by likes in the last 7 days'). It distinguishes itself from sibling tools by focusing on HuggingFace community trends, 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 explicitly states when to use the tool: 'Use when the agent needs to surface what the open-source AI community is paying attention to right now.' Although it doesn't mention alternatives or exclusions, the sibling tools cover clearly different domains (e.g., BTC price, climate), so the context is sufficient.

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 explicitly calls this a 'GET endpoint' that 'returns remaining credits,' indicating a read-only operation. However, the annotations declare readOnlyHint: false, which means the tool is not marked as read-only. This directly contradicts the description's implied behavior, so the transparency score is 1 and an annotation contradiction is flagged.

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: it immediately states what the tool does, then supplies authentication and cost details, and ends with the primary use case. Every sentence adds value with no redundant information.

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

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

For a zero-parameter tool, the description is quite complete: it specifies the endpoint, auth requirement, cost, and intended use. The only gap is that it does not describe the response format, but the absence of an output schema and the simplicity of the resource make this a minor omission.

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 schema coverage is trivially 100%. The description adds meaningful context about the required Authorization header format (Bearer tf_live_<64-char-hex>) and that the operation costs 0 credits, which goes beyond the empty schema.

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

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

The description clearly states the tool is a GET endpoint that returns remaining credits for the bearer token, with a specific verb and resource. It distinguishes itself from sibling payment tools like tf_payment_buy_credits and tf_payment_history by focusing specifically on balance 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 provides clear context for when to use the tool ('Use to monitor agent budget') and implies it is a lightweight operation by noting it costs 0 credits. However, it does not explicitly name alternative tools or state when not to use it, which prevents a perfect score.

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

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

Annotations already indicate readOnlyHint=false, openWorldHint=true, and idempotentHint=false, so the agent knows it is a mutating, non-idempotent call. The description adds valuable context about the address and conversion rate, but it does not disclose what mutation actually occurs (e.g., whether it creates a payment order or just returns a quote), leaving ambiguity about side effects beyond returning data.

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 exactly two sentences, front-loaded with the core behavior, and every piece of information (endpoint, address, memo, quote, rate, use case) is purposeful. No wasted words or redundant 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?

Since there is no output schema, the description effectively explains what the tool returns (address, memo, quote) and gives operational details (rate, first step). It does not mention error cases or explicitly reference the follow-up tf_payment_confirm, but the sibling list and purpose are clear enough for a simple single-parameter tool.

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

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

Schema description coverage is 100% because amount_usd has a description ('USDC amount to convert. Minimum $1 = 50 credits.'). The tool description repeats the conversion rate but does not add new parameter meaning beyond what the schema already provides, so it stays at 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 verb and resource: 'POST endpoint that returns the published USDC wallet address... a unique memo, and a quote.' It distinguishes itself from payment siblings by emphasizing its role as the initial step for buying credits, not for checking balance, confirming, or history.

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 explicit usage context: 'Use as the first step when the agent needs to buy credits to access /api/pro/* endpoints.' However, it does not explicitly mention when not to use it or compare with alternatives like tf_payment_balance or tf_payment_confirm, so it lacks full 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?

With annotations already indicating non-read-only and non-idempotent behavior, the description adds context by specifying it is a POST endpoint, verifies on-chain transfer, and returns a cross-redeemable token. It does not detail failure modes or rate limits, but the annotations cover the basic 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?

Three concise sentences, each with a distinct purpose: what it does, when to use it, and what the result means. No redundant phrasing.

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 no output schema, the description fully covers the return value (token and credit count), the necessary context (tx hash and memo), and the post-verification usage (cross-redeemable). It is complete for an agent to use this tool correctly.

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

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

Schema coverage is 100%, but the description reinforces that both tx_hash and memo are expected in practice despite being schema-optional. It clarifies the workflow by linking the nonce to the memo from tf_payment_buy_credits, which adds operational nuance 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 verifies a Base mainnet USDC transfer and returns a bearer token plus credit count. It names the specific token format (tf_live_<64-char-hex>) and distinguishes this from sibling payment tools like tf_payment_buy_credits or tf_payment_balance.

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

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

Explicitly says 'Use after the agent has sent USDC' and directs the agent to provide the tx hash and memo from tf_payment_buy_credits. This establishes a clear workflow and timing, making it obvious when this tool should be invoked relative to its siblings.

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

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

The description states it is a GET endpoint that returns data, implying a read-only operation. However, the readOnlyHint annotation is false, indicating the tool is not read-only. This contradiction—description implying read-only while annotation says otherwise—warrants a score of 1 and constitutes an annotation contradiction. The description also fails to disclose any potential side effects that the annotation hints at.

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

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

The description is three sentences, front-loaded with the core purpose. It packs in the return fields, auth requirements, credit cost, and an edge case without any wasted words. Every sentence earns its place.

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

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

The description covers the essential aspects: purpose, auth, cost, and an edge case for old tokens. It lists return fields, which compensates somewhat for missing output schema. However, the contradiction with annotations undermines completeness—if the tool is not read-only, the description fails to mention any side effects. Also, no error handling or pagination details are given, though for a simple history endpoint this is acceptable. Overall, it's functional but not comprehensive.

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 zero parameters, so the schema coverage is trivially 100%. With 0 params, the baseline is 4. The description adds no parameter info because none exist, which is appropriate. The mention of Authorization header is authentication, not a parameter.

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

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

The description clearly identifies the tool as a GET endpoint that returns confirmed USDC purchases with specific fields, plus balance and totals. This specific verb+resource definition distinguishes it from siblings like tf_payment_balance (which likely only returns balance) and tf_payment_confirm (which confirms payments).

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: requires Authorization Bearer header with a specific token format, costs 0 credits, and describes behavior for old tokens. Though it doesn't explicitly name alternatives, the description implies its role as a payment history endpoint. A minor gap is the lack of explicit 'use this when you need purchase history vs. other 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 readOnly/openWorld/idempotent. The description adds valuable behavioral context: cache TTL of 60s, sorting by 24h volume, and that markets are active (not closed).

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

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

Three sentences, no filler. Each sentence contributes: what it fetches, what's included, and when to use it.

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

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

Given no params, no output schema, and rich annotations, the description covers the return fields (question, outcomes, volume), the cache behavior, and the intended use case. It is sufficient for an agent to decide when to invoke it and 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 tool has zero parameters, so there is no parameter documentation burden. The description doesn't need to explain inputs, and schema coverage is 100%.

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 verb ('Fetches') and resource ('active Polymarket prediction markets sorted by 24h volume'), unambiguously distinguishing it from sibling tools like tf_btc_price or tf_crypto_movers.

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

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

The description explicitly states when to use it: 'Use when the agent needs market-implied probabilities on world events (elections, sports, macro).' It lacks explicit exclusion or alternative tool references, but the use case is clear.

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

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

Beyond annotations, the description discloses key behaviors: it uses a 5-minute cache, requires bearer auth, costs 2 credits ($0.04 USDC), returns both a structured JSON object and a pre-formatted system_prompt string, and notes a recent content removal due to licensing compliance. This fully characterizes the tool's operational traits without contradicting 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?

Despite being long, every sentence serves a purpose: purpose, contents, output format, benefit, cost, cache, auth, and recent change. The description is front-loaded with the 'always start here' directive and maintains density without 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 zero-parameter tool with no output schema, this description is remarkably complete. It covers what data is included, the return format, the cost, caching behavior, authentication requirements, and even a recent content change. The only minor gap is the lack of an example JSON structure, but the high-level enumeration is sufficient.

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

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

The tool has zero parameters, so with schema coverage at 100% (empty schema) and no parameters to explain, the baseline of 4 applies. The description adds value by explaining the dual output format, which is more relevant than parameter details here.

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

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

The description clearly identifies the tool as the 'always start here' premium call and lists exactly what it composes: Fed funds rate, USD-forex pairs, HN top 5, earthquakes, space launches, Polymarket markets, and infrastructure status. This strong verb+scope distinguishes it from sibling tools that cover only subsets of this data.

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

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

The phrase 'always start here' gives a direct when-to-use instruction, and 'Saves the agent from making many separate calls' clarifies the value proposition. However, it does not explicitly mention when not to use it or name alternative sibling tools for specific needs, leaving the exclusion implicit.

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

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

Discloses important behavioral details beyond the annotations: 'Costs 1 credit ($0.02 USDC),' 'Requires Authorization: Bearer tf_live_<64-char-hex>,' and notes that 'crypto legs were removed 2026-07-23 for market-data licensing compliance.' This goes well beyond the sparse readOnlyHint/openWorldHint/idempotentHint annotations, though it does not detail the exact output structure.

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 somewhat long but every sentence adds distinct value: premium positioning, added features, section list, cost, auth, free alternative, and a regulatory note. It is front-loaded and ends with a relevant caveat, 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?

Covers the tool's purpose, usage condition, pricing, auth, section list, and a behavioral note about removed crypto legs. No output schema exists, but the section list implicitly conveys the payload shape. A minor gap is the lack of explicit response format description, but the description remains complete enough for practical 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 schema already documents the include parameter with 100% coverage, so the baseline is 3. The description adds practical meaning by explaining that it 'supports section filtering via ?include=' and listing the exact comma-separated values (earthquakes, hackernews, humans-in-space, launches, predictions). It also clarifies the default: 'Omit for all sections.'

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 this as the 'Premium version of tf_briefing' and specifies that it 'Adds Polymarket prediction markets to the standard briefing payload.' It explicitly lists covered sections (earthquakes, Hacker News, humans in space, launches, prediction markets), which distinguishes it from the sibling tf_briefing.

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

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

It states explicitly when to use this tool: 'Use when the agent needs prediction-market context in addition to the basic snapshot.' It also names the alternative, 'Free basic version (without predictions) available at tf_briefing (no auth required),' and notes 'Strict premium, no free trial.'

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 discloses cost (2 credits), caching (30-min), authentication (Bearer), data source (FRED public domain), and a licensing compliance note. These add significant context beyond the annotations and clarify the non-read-only nature (credit consumption) 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 efficiently structured, front-loading the core purpose and then adding pertinent details about output format, cost, cache, auth, and licensing. Every sentence earns its place without 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?

For a zero-parameter, pre-computed tool with no output schema, the description fully specifies expected outputs (sorted pairs array, NxN matrix, strength/direction tags), operational constraints (cost, cache, auth), and data limitations. It leaves no significant gap for an agent to invoke it correctly.

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

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

With zero parameters, the schema is fully covered and the description clarifies that no input is needed. The description does not need to explain parameter syntax, but it confirms the tool is pre-computed and requires no user configuration, matching the baseline for 0 params.

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

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

The description clearly states the tool returns a pre-computed macro correlation matrix with a specific verb ('Returns') and resource (correlations for 4 named FRED series). It distinguishes itself from siblings like tf_premium_macro or tf_economic_data by specifying the exact output (pairs array + NxN matrix) and data 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 implies usage for AI trading and portfolio agents needing macro correlations, and notes the data coverage and removal of crypto/equity legs. It does not explicitly mention alternatives or exclusions, but the context is clear enough for an agent to decide when to use this tool versus others.

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

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

Despite annotations indicating non-read-only and non-idempotent, the description transparently discloses that it costs 2 credits, requires Authorization, and has a no-charge condition for stalled monitors. It explains the scoring methodology and data freshness, adding significant value 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 relatively detailed but every sentence adds value: it covers purpose, scoring, free preview, cost, auth, and data freshness. It is well-structured but could be slightly tightened without losing information. Earns a 4 for being efficient and informative.

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

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

Given there is no output schema, the description thoroughly explains the return fields (composite score, subscores, trust tier, low_coverage flag, captured_at), the underlying data source, the free preview alternative, authentication, and cost. It leaves little ambiguity about what the tool does and its caveats.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter-specific details because there are none, and the schema already covers everything (100% coverage). No extra semantic information needed.

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 it returns: a premium reliability breakdown with composite scores, subscores, trust tier, and low_coverage flag. It distinguishes from the free preview but does not explicitly differentiate from sibling tools like the history endpoint. Lacks a specific verb like 'Get' or 'Retrieve', so falls short of a 5.

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

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

Provides context about when charges apply (stalled monitor >48h no charges) and mentions the free preview as an alternative. However, it does not explicitly state when to use this instead of other premium tools (e.g., history vs. current breakdown). Guidance is implied rather than explicit.

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

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

The description discloses several behavioral details beyond the annotations: 'query window capped at 365 days', 'Immutable past data', 'empty range no-charges', 'Costs 2 credits ($0.04 USDC)', and 'Requires Authorization: Bearer tf_live_<64-char-hex>'. These cover cost, auth, data immutability, and parameter constraints, providing significant context beyond readOnlyHint/openWorldHint/idempotentHint.

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

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

The description is three sentences, front-loaded with the primary purpose, and packs all necessary details (parameters, cap, cost, auth, alternative) without fluff. Every sentence 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?

The description covers purpose, parameters, time bounds, cap, cost, auth, and a pointer for feed ids. It does not describe the output structure (no output schema exists), and the implied requirement for feed contradicts the schema's optionality. For a paid tool with 3 params and no output schema, this is nearly complete but leaves minor gaps around response format and parameter requiredness.

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 descriptions already cover each parameter (feed, from, to) with format examples. The description adds a query-window cap ('capped at 365 days') and billing nuance ('empty range no-charges'), which go beyond the schema. However, it implies feed is required ('for one feed') while the schema's required list is empty, creating slight ambiguity about whether feed can be omitted.

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

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

The description uses a specific verb and resource: 'Returns the daily composite-reliability time-series for one feed' with an example feed. This clearly distinguishes it from the sibling tf_premium_feed_reliability, which likely provides current reliability. The phrase 'history' in the tool name is reinforced by 'daily ... time-series.'

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

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

The description clearly implies usage for historical reliability data ('Premium reliability history', 'daily ... time-series'). It also provides a cross-reference for getting current feed ids: 'Use the free GET /api/feed-reliability for current feed ids.' However, it doesn't explicitly contrast with the sibling tf_premium_feed_reliability or state when not 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?

The disclosure includes important behavioral traits beyond annotations: cost (2 credits), 30-min cache, Bearer auth, and data source. These are useful for an agent evaluating side effects and prerequisites. The annotations provide only openWorldHint and idempotentHint, so the description adds meaningful context, though it could mention rate limits or error behavior.

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

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

The description is concise and front-loaded: the first sentence summarizes the tool's role, and the second sentence packs detailed output specifications and operational metadata (source, cost, cache, auth). Every sentence earns its place, with no fluff or repetition of structured 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?

Despite having no output schema, the description enumerates the exact data returned (top 30 repos with fields, top 15 AI/ML repos, aggregates, share) and gives operational constraints (cost, cache, auth). For a complex composed tool, this is very complete and leaves few unanswered questions.

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 the input schema is fully self-documenting (coverage 100% vacuously). Per the baseline, a 0-parameter tool gets a 4. The description correctly does not attempt to explain nonexistent parameters, and no additional semantic value is needed.

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 returns a composed GitHub developer-attention snapshot with specific data (top 30 repos, top 15 AI/ML-focused repos, aggregates, and AI/ML share). The verb 'Returns' and explicit list of outputs distinguish it from sibling tools, which focus on other domains (e.g., climate, crypto, Hugging Face).

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: when needing GitHub trending/velocity data with AI/ML focus. It mentions the source (GitHub Search API), cost, cache, and auth requirements, which help the agent judge operational fit. However, it does not explicitly state when not to use it or name alternatives, so it misses the explicit exclusion criterion.

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 goes beyond annotations by disclosing cost (2 credits), authentication requirement, source licensing, and a changelog note about removed indices. This adds valuable behavioral context without contradicting the annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false).

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

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

The description is a single, well-structured paragraph that front-loads the main purpose and then concisely covers contents, sources, cost, auth, optional parameter, and a removal note. Every sentence provides useful information with 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?

Despite having no output schema, the description gives a thorough overview of what the tool returns (FRED series, forex pairs, oil/gas), the historical option, and important caveats. It is sufficiently complete for an agent to decide when and how to 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?

The single optional parameter is fully documented in the input schema (100% coverage). The description briefly repeats the history=30d behavior but adds no new details beyond what the schema already states, so it does not significantly compensate or enhance parameter understanding.

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

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

The description clearly states the tool's action: 'Premium composed macroeconomic snapshot in one HTTP call.' It lists the specific contents (FRED series, forex pairs, oil/gas) and distinguishes itself from siblings by being a composed macro snapshot rather than a single-asset or economic data point tool.

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

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

The description provides clear context for when to use the tool: for a one-call macro snapshot with cost, auth, and optional history details. However, it does not explicitly mention alternatives or exclusions, lacking direct comparison to siblings like tf_economic_data or tf_forex.

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 substantial behavioral context beyond annotations: 'Costs 2 credits ($0.04 USDC),' 'Bearer auth required,' '1-hour rolling cache; sub-second when warm,' and clamping behavior. It also describes the event structure. Annotations indicate readOnlyHint=false, but the description does not discuss potential side effects beyond billing, which is a minor gap. 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 efficiently structured: it opens with the primary purpose, enumerates sources, then covers parameters, event structure, value, cost, auth, and caching. Each sentence adds distinct information with no fluff, making it appropriately sized for a tool with one parameter and multiple behavioral facets.

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 no output schema, the description compensates by specifying event fields ('type, timestamp, severity, and structured data') and the time-sorted feed order. It also covers cost, auth, caching, and parameter behavior. It lacks details on response envelope or pagination, but for an event stream with simple input, it is nearly complete.

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

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

The input schema already fully describes the 'since' parameter with 100% coverage, including defaults and clamping. The tool description repeats this information without adding new meaning. Baseline of 3 is appropriate since the schema carries the burden; the description adds no extra 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: 'Aggregates time-stamped events from 4 sources into one time-sorted feed,' naming specific sources (USGS, Hacker News, Polymarket, space launches). This specific verb+resource scope distinguishes it from sibling tools like tf_earthquakes or tf_hf_trending, and the value proposition 'Saves an agent from polling 5 separate upstream feeds' reinforces its unique role.

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: it is 'for monitor agents' and consolidates multiple feeds, saving polling time. However, it does not explicitly name alternatives or state when not to use it (e.g., when only one source is needed). The guidance is implied rather than explicit, so a 4 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 readOnly, idempotent, and openWorld hints. The description adds useful behavioral context, specifically the 60-second cache TTL, and lists the services covered. It does not describe return format or error handling, but this is a simple fetch tool and the cache detail is valuable.

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 no wasted words. All information is relevant and efficiently presented.

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, no-output-schema tool, the description provides complete context: purpose, usage, and cache behavior. It adequately covers what the agent needs to know to select and invoke correctly.

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

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

Tool has zero parameters, so the baseline is 4. There are no parameter semantics to add, and the description appropriately omits any parameter discussion.

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 ('Fetches operational status') and resource ('major dev infrastructure') with a list of services, distinguishing it from sibling tools that focus on other domains like crypto, weather, and AI stack CVEs.

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

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

Explicitly provides when to use: 'Use when the agent needs to know if a dependency is up or to explain a recent outage.' This is clear context and no alternative tool is needed since siblings are unrelated.

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, openWorldHint, and idempotentHint, indicating a safe read operation. The description adds concrete behavioral context: the source endpoint, the specific RPC methods used, and the 30-second cache TTL, which helps the agent understand data freshness and provenance.

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, each carrying essential information: the first lists all returned metrics, the second gives source, cache behavior, and usage context. It's front-loaded with the main action and contains no extraneous words.

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

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

For a simple parameterless read-only tool, the description covers what data is returned, the source, the cache behavior, and when to use it. All relevant details are included, and while there is no output schema, the description explicitly lists the fields, making it self-sufficient.

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

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

There are zero parameters, so no schema semantics are needed. Per the rubric, a zero-parameter tool receives a baseline of 4. The description adds value by listing the output metrics even though it doesn't discuss parameter syntax.

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

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

The description specifies the exact resource (Solana mainnet network metrics) and enumerates the specific data points returned (TPS, average TPS, slot, slot time, epoch progress). This clearly distinguishes it from sibling crypto tools like tf_btc_price or tf_crypto_movers, which focus on prices rather than network throughput.

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

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

Explicitly states the intended use case: 'Use when the agent needs to assess Solana network throughput or congestion.' This is clear context, but it doesn't mention when not to use it or name alternatives; however, given no sibling tool provides Solana network metrics, the implied sole purpose is sufficiently clear.

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