x402-factory

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

No annotations, so the description carries the burden. It discloses the cost ($0.001, cheapest), the payment mechanic (x402), and the return shape (ok + server time + paid flag), which is strong behavioral context. It doesn't specify latency, failure modes, or retry behavior, keeping it out of the top band.

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

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

Front-loads the core purpose, then the return, then the usage guidance, then pricing/docs metadata. Slightly dense with the bracketed metadata line, but every element is functional.

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-param health-check with no output schema, the description covers purpose, cost, return fields, and usage. It could note auth/rate-limit behavior, but it is complete enough to call 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?

Zero parameters, so baseline is 4. The description correctly implies no inputs are needed for a ping, and the schema's additionalProperties:false is consistent.

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

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

States a specific verb+resource ('liveness plus x402 payment pipeline check') and clearly distinguishes itself from all the data-heavy siblings as the cheapest health-check endpoint. The 'Cheapest endpoint' framing and the HTTP path make its identity 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?

Explicitly says when to use it: 'verify your x402 client end to end before spending on data endpoints.' This names the precise precondition (before spending) and the goal, giving the agent a clear routing rule versus the expensive data tools.

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

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

With no annotations, the description carries the full load and does well: it discloses ordering ('sorted soonest first'), the data source (agencies' published calendars), and the access/pricing model ($0.01 via x402, GET /v1/econ/calendar). It does not state pagination, coverage window, or failure behavior, which keeps it out of the top score.

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?

Purpose is front-loaded, and the bracket cleanly packs endpoint, price and docs link. Sentences one and two partially restate the same 'all tracked US economic series' scope, a minor redundancy that keeps it from a 5.

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, no parameters and no annotations, the description supplies everything an agent needs to decide to call it: what comes back, in what order, from where, and at what cost. Only the coverage window and response shape are left unspecified.

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

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

The tool takes zero parameters, so the baseline is 4. The description's use of 'Upcoming' correctly signals that there is no date-range or filter argument, but it never explicitly says the call takes no inputs.

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

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

States a specific verb (release dates) and resource (US economic series), plus the exact scope ('all tracked series') and that CPI, payrolls, GDP, PCE, claims and housing are included. It is clearly distinguishable from the econ_series_* siblings, which return a single full series view.

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 line 'The cheap planning read before paying for a full series view' gives an explicit selection rule relative to the econ_series_* siblings, including the cost rationale. It stops short of naming a specific alternative tool or stating when this is not appropriate.

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

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

With no annotations, the description carries the full burden and largely meets it: it discloses the return contents (latest headline print, its date, a revised flag, next scheduled release dates), the transport (HTTP GET /v1/econ/dashboard), and that the call costs $0.03 via x402 — the payment/auth requirement is a genuinely useful behavioral disclosure. It stops short of stating rate limits, freshness/latency, or an explicit read-only guarantee.

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

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

The core claim is front-loaded, but sentences two and three restate sentence one almost verbatim ('every tracked series' latest print in one call' vs 'All tracked US economic series in one response'), so roughly a third of the text is redundant. The bracketed endpoint/price/docs block is dense but earns its place as operational metadata.

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

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

With no output schema and no annotations, the description must describe results itself, and it does: latest print, date, revised flag, and next release date per series. That is adequate for an agent to decide whether the payload has what it needs, though field names or response shape are not specified.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain; baseline 4 applies. The description correctly avoids inventing arguments, and 'in one call' reinforces that no filtering inputs exist.

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

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

States a specific verb+resource ('US macro dashboard: every tracked series' latest print in one call') and explicitly contrasts itself with the per-series siblings by framing it as a replacement for fanning out fifteen reads. An agent can distinguish this from econ_series_cpi, econ_series_gdp-growth, etc., without opening any schema.

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

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

The phrase 'for agents that would otherwise fan out fifteen reads' gives a clear selection condition against the single-series siblings, but it never names econ_dashboard_changes or econ_dashboard_delta, which are the closest ambiguous alternatives, nor states any 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?

No annotations, so the description carries the full burden, and it does: discloses the cost model (free via x402), the exact return payload (changed_count, next_cursor, as_of, no rows), and the recommended polling cadence. This is materially more than the schema provides and directly shapes how the agent should behave.

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

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

Front-loaded with 'Free' and the core purpose, and each sentence carries weight (return shape, polling strategy). The trailing bracketed HTTP/pricing/docs metadata is useful but slightly less essential, keeping it just under full marks.

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

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

For a single-parameter, no-output-schema tool, the description is complete: it explains the response fields the missing output schema would otherwise cover and clarifies the free-vs-paid workflow. An agent has everything needed 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?

Schema description coverage is 100%, so the 'since' cursor is already fully documented in the schema ('Opaque cursor from a previous next_cursor; omit once to bootstrap'). The description only restates 'since your cursor', adding no syntax or edge-case detail beyond the schema; baseline 3 applies.

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

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

States a specific verb+resource with scope: a count of econ observations printed or revised since a cursor. It explicitly distinguishes itself from its closest sibling (econ_dashboard_delta) by noting it returns 'changed_count, next_cursor, and as_of only — no rows', so an agent can route between the free probe and the paid delta without opening either schema.

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

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

Gives an explicit when-to-use and when-not: poll hourly for $0 and only call the paid delta when changed_count > 0. The alternative (delta) is named and the gating condition is spelled out, leaving nothing to inference.

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

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

With no annotations the description carries the full burden, and it does well: it discloses the paid cost ($0.015 via x402), the GET endpoint, that cursors are stable across restarts, and the returned fields. It stops short of describing behavior on a stale/invalid cursor or an empty delta, which keeps it from a 5.

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

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

The core content is front-loaded, but the opening fragment 'Only the econ observations printed or revised changed since your cursor (delta o.' is garbled and then immediately restated by the following sentence, so a meaningful portion of the text is redundant rather than additive.

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

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

For a single-param cursor tool with no output schema, the description covers bootstrap, incremental fetch semantics, payment model, cursor durability, and the cheap sibling alternative. Only edge-case behavior (invalid/expired cursor, empty results) is unaddressed.

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 parameter has 100% schema coverage, so baseline is 3, but the description adds real meaning beyond the schema by framing since as the next_cursor from your previous call, explaining the bootstrap case, and asserting cross-restart cursor stability — semantics an agent needs to use the cursor correctly.

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

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

States a specific operation (keyset delta of /v1/econ/dashboard) and scope (only econ observations printed or revised since a cursor), returning changed_count plus a new next_cursor. It also names and distinguishes the sibling econ_dashboard_changes (free counts) from the full econ_dashboard, so an agent can route without opening schemas.

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 to pass since=<next_cursor from your last call>, to omit since once to bootstrap, and to poll the free sibling /v1/econ/dashboard/changes first so you 'pay only when there is something to fetch.' This is the when/when-not/alternative guidance at its clearest.

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

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

With no annotations, the description carries the burden and does so well: it discloses the data provenance (public-domain federal data only), the payment requirement ($0.02 via x402), and the substantive semantics (first-release vs latest value, revisions never shown as print-day numbers, market-implied vs trend-model surprise). It omits rate limits or caching/refresh behavior, but the core behavioral profile is present.

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

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

Front-loaded with the payoff, then the data semantics, then the endpoint/pricing/docs footer. Dense but not padded, though the parenthetical asides make it read longer than needed for a one-parameter 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?

No output schema exists, and the description compensates by enumerating the returned fields (latest print, first-release vs latest, surprise, next release date, 12-observation mini-series). The only real gap is sibling differentiation against the per-series variants.

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

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

Single parameter with 100% schema description coverage, so the schema already explains the 'series' slug, gives examples, and points at the calendar endpoint. The description adds the notion that only one series is tracked per call but no extra syntax or format detail.

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

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

States a specific verb (retrieve) and resource (one tracked US economic series) plus source lineage (BLS/BEA/Fed/Census via FRED/ALFRED). However, it never distinguishes itself from the near-identical siblings econ_series_cpi, econ_series_payrolls, etc., which an agent must choose between.

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

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

No when-to-use statement, no routing to alternatives. The description implies the tool is the generic parametrized lookup but is silent on why one would pick it over econ_series_cpi or econ_series_payrolls, and only the schema mentions econ_calendar for enumerating slugs.

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

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

With no annotations, the description carries the full burden and largely meets it: it discloses that revisions are flagged separately from first-release values ('revisions never pose as print-day numbers'), how surprise is computed (market-implied when a matching prediction market exists, else trend-model), the next release date, and a 12-observation window. It also exposes the transport (HTTP GET) and the paid access path ($0.02 via x402), which is unusual and useful operational context.

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

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

Front-loaded with the resource and the three headline outputs, then progressively less critical detail. The middle run-on about first-release vs latest and market-implied vs trend-model surprise is dense but each clause carries meaning; little is wasted.

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

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

No output schema exists, so the description is responsible for describing the return payload and does so thoroughly (fields, revision flagging, surprise origin, horizon, release date). It also mentions the endpoint, cost, and docs link, leaving little an agent would need to call and interpret it correctly.

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

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

The tool takes zero parameters and additionalProperties is false, so there is no parameter semantics to document. The baseline for a 0-param tool is 4.

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

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

States a specific resource and dataset origin: 'Building permits (Census, monthly)', then enumerates what it returns (print, revisions, surprise, next release, mini-series). The line 'Same shape as /v1/econ/:series bound to building-permits' clarifies how it relates to the generic econ_series family, though it never names a sibling tool like econ_series_housing-starts explicitly.

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

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

There is no when-to-use or when-not-to-use guidance. The description does not say when to pick this over econ_series, econ_series_housing-starts, or econ_calendar, nor does it state any preconditions. Usage is only implied by the data it returns.

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

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

With no annotations, the description carries the full load and does disclose real behavior: first-release vs latest value with a revised flag, surprise methodology (market-implied when a matching prediction market exists, else trend-model), and next release date. It also notes cost ($0.02 via x402) and HTTP method. Auth/rate-limit behavior is not covered, keeping it short of a 5.

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

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

Front-loaded summary sentence followed by the payload breakdown; the bracketed HTTP/price/docs tag is useful metadata. Minor redundancy between the first two sentences ('Core CPI inflation ... latest print, revisions, surprise' restated as 'Latest Core CPI inflation print ...'), but overall efficient.

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

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

No output schema and no annotations exist, yet the description enumerates the returned fields (revised flag, surprise vs labeled expectation, next release date, mini-series) well enough for an agent to know what comes back. Missing only the JSON shape detail that an output schema would normally supply.

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?

Zero parameters, so baseline 4 applies. The description correctly describes a no-argument, fixed-series endpoint rather than implying any filter or query options.

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

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

States a specific resource (Core CPI from BLS, via FRED/ALFRED) and the exact payload (latest print, revisions, surprise, next release, 12-observation series). The line 'Same shape as /v1/econ/:series bound to core-cpi' cleanly distinguishes it from the generic econ_series and the adjacent cpi/core-pce/pce-inflation siblings.

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

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

The 'bound to core-cpi' framing implies this is the series-specific variant of econ_series, so usage is inferable. But it never states when to pick this over econ_series_cpi (headline) or core_pce, nor any exclusions. Guidance is present but only implicit.

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

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

With no annotations, the description carries the full burden and does well: it discloses provenance (FRED/ALFRED), states that 'revisions never pose as print-day numbers', and explains the surprise methodology including the market-implied vs trend-model fallback. It also surfaces an operational trait (price $0.02 via x402). It stops short of describing staleness/latency or pagination for the mini-series.

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

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

Front-loaded with the key noun phrase and structured as capability list plus operational footer. It is somewhat repetitive, restating 'latest print, revisions, surprise' twice ('latest print, revisions, surprise' then 'first-release vs latest value ... surprise vs a labeled expectation'), and the bracketed HTTP/price/docs line is dense but useful.

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

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

There is no output schema and no annotations, so the description fully shoulders the burden — and it enumerates the return shape (first-release vs latest value, revised flag, surprise, next monthly release date, 12-observation mini-series). An agent knows exactly what it will receive and can call it correctly with no arguments.

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

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

The tool takes zero parameters, so per the baseline this scores 4. Nothing in the description contradicts or must compensate for a parameter schema that does not exist.

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

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

States a specific verb+resource+scope: 'Core PCE inflation (BEA, monthly): latest print, revisions, surprise.' It also distinguishes itself from the generic sibling by noting it is the 'same shape as /v1/econ/:series bound to core-pce', making it differentiable from econ_series and econ_series_core-cpi despite 200+ siblings.

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

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

Usage is implied through the data it returns (latest print, revisions, surprise, next release date) rather than stated. It never says when to prefer this over econ_series_pce-inflation or econ_series_core-cpi, so routing among the near-identical econ_series_* siblings is left to inference from the series 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?

With no annotations, the description carries the full burden and does meaningfully more than name the tool: it discloses that revisions are flagged and never presented as print-day values, that surprise is measured against a labeled expectation whose source varies (market-implied when a matching prediction market exists, else a trend model), and it exposes the x402 price and HTTP endpoint. It does not cover failure modes or staleness handling, which is the only notable gap for a read tool.

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

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

The return payload (latest print, revised flag, surprise, next release date, 12-observation mini-series) is front-loaded before the source and transport details. It is dense and slightly overstuffed with HTTP/pricing/docs metadata, but every sentence carries information an agent can act on.

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 effectively stands in for the missing return-value documentation by enumerating the fields the payload contains. What is missing is the contrast with sibling CPI/PCE series, which matters given how many near-duplicate econ_series_* tools exist.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description correctly implies the series is fixed (cpi) rather than selectable, consistent with the empty, additionalProperties:false schema.

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

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

The description opens with a specific verb+resource+source: 'CPI inflation (BLS, monthly): latest print, revisions, surprise.' It also names the underlying route binding (/v1/econ/:series bound to cpi). It stops short of explicitly contrasting headline CPI against the sibling econ_series_core-cpi or econ_series_pce-inflation, so the agent must infer the distinction.

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

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

Usage is implied rather than stated: the agent can infer it should call this for headline CPI and call econ_series_core-cpi or econ_series_pce-inflation for the variants, but no when-to-use or when-not-to-use rule is given, and no alternative is 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?

With no annotations the description carries the full burden and does disclose meaningful behavior: revisions are flagged and 'never pose as print-day numbers', surprise is market-implied when a matching prediction market exists else trend-model, plus next release date and a 12-observation series. It also exposes pricing ($0.02 via x402) and the HTTP endpoint. It does not cover pagination or caching, but the content-level transparency is strong.

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?

Key content is front-loaded, but the opening sentence ('latest print, revisions, surprise') is immediately restated by the following sentence ('Latest Effective fed funds rate print from the Fed via FRED/ALFRED'), which is redundant bulk that could be tightened.

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

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

With no output schema and no annotations, the description must convey the return shape, and it does list the payload components (first-release vs latest with revised flag, labeled surprise, next release date, 12-obs mini-series). Coverage is good, though it stops short of describing field formats or freshness/latency guarantees.

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

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

The tool takes zero parameters, so the schema baseline is 4 and no further parameter explanation is required; the description correctly spends no effort on 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?

States a specific verb+resource: it returns the Effective fed funds rate monthly series with latest print, revisions, and surprise. The phrase 'bound to fed-funds' plus the explicit metric differentiates it from the generic econ_series and from sibling series such as econ_series_cpi or econ_series_unemployment.

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 note 'Same shape as /v1/econ/:series bound to fed-funds' implicitly routes the agent to this specialization over the generic series tool, but there is no explicit when-to-use versus when-not guidance or named alternatives/enumeration of conditions.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: 'first-release vs latest value with a revised flag (revisions never pose as print-day numbers)', 'surprise vs a labeled expectation', and includes a next release date. This proactively addresses data reliability and provenance. It does not mention rate limits or authentication (though it notes pricing via x402).

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

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

The description is front-loaded with the core purpose: 'Real GDP growth (BEA, quarterly): latest print, revisions, surprise.' It then elaborates with necessary details and ends with HTTP method, price, and docs link. It is appropriately sized for its complexity, though the parenthetical sentence is slightly dense. 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?

Given no annotations, no output schema, and 0 parameters, the description does a thorough job of explaining what the tool returns (first-release vs latest, revised flag, surprise, next release, 12-observation series) and how it relates to the generic econ_series. It includes access details (GET endpoint, price, docs). It lacks explicit authentication info, but pricing via x402 implies a payment flow.

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?

Parameter count is 0, so baseline is 4. The description does not add parameter semantics (none needed), but it does clarify the output structure: 'same shape as /v1/econ/:series' and lists returned fields (first-release vs latest, revised flag, surprise, next release date, 12-observation mini-series). This adds value 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 states a specific verb+resource: 'Latest Real GDP growth print from the BEA via FRED/ALFRED'. It names the source (BEA via FRED/ALFRED), the metric (Real GDP growth), and the frequency (quarterly). It also explicitly distinguishes itself from the sibling econ_series with 'Same shape as /v1/econ/:series bound to gdp-growth', making clear it is not the generic series 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 clearly indicates when to use this tool: for the latest real GDP growth print with revisions, surprise, next release date, and mini-series. It references the sibling econ_series to clarify scope. However, it does not provide explicit when-not-to-use guidance or name alternative tools for other economic indicators (though sibling names like econ_series_cpi imply 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?

With no annotations, the description carries the full behavioral burden and does unusual work: it discloses revision handling ('revisions never pose as print-day numbers'), the surprise-vs-expectation methodology (market-implied when a prediction market exists, else trend-model), the monthly cadence, and the $0.02 x402 price. It stops short of auth/rate-limit/error behavior, keeping it below a 5.

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

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

The opening fragment 'Housing starts (Census, monthly): latest print, revisions, surprise' front-loads the essence, and subsequent sentences each add a distinct fact (revision semantics, expectation source, release date, series length) rather than padding. The trailing HTTP/price/docs bracket is compact metadata.

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, no annotations, and no parameters, the description must supply the return contract itself, and it does: it names the source, cadence, fields returned, revision flag semantics, surprise expectation source, next release date, and the 12-observation series length, plus a docs URL. Nothing an agent needs to interpret the response 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 tool takes zero input parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify beyond confirming the series is already bound, which it does via the FRED/ALFRED reference.

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

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

The description states a specific verb and resource – it delivers the latest Housing starts print from Census via FRED/ALFRED – and enumerates the exact payload (first-release vs latest value, revised flag, surprise, next release date, 12-obs mini-series). It distinguishes itself from the generic sibling by noting it is 'the same shape as /v1/econ/:series bound to housing-starts,' so an agent can tell it apart from econ_series and from econ_series_building-permits without opening a schema.

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

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

Usage is only implied: naming the Census/FRED source and the 'monthly' cadence plus the sibling relationship tells the agent roughly the domain, but there is no explicit when-to-use vs when-to-use-an-alternative guidance (e.g. this vs econ_series or econ_calendar). No exclusions or prerequisites are stated.

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

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

With no annotations the description carries the full burden, and it does well: it discloses data provenance (FRED/ALFRED), cadence (weekly), revision handling ('revisions never pose as print-day numbers'), how surprise is derived (market-implied if a matching prediction market exists, else trend-model), and the paid access path ($0.02 via x402). It stops short of error/rate-limit behavior, but the safety-relevant context is unusually complete.

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

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

Front-loaded with the series and payload summary, then the detail. There is mild redundancy – 'Initial jobless claims (DOL, weekly): latest print, revisions, surprise' is restated at length in the next sentence – and the HTTP/price/docs bracket is metadata rather than description, but nothing is seriously wasted.

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

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

No annotations and no output schema, so the description must explain the return payload itself, and it does: first-release vs latest value, revised flag, labeled expectation, next release date, and the 12-observation mini-series. Nothing an agent needs to call and interpret this zero-param endpoint 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?

There are zero input parameters, so the baseline of 4 applies. The description adds useful framing about what the (parameterless) call returns rather than needing to document inputs.

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

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

States a specific verb/resource (latest Initial jobless claims print from DOL via FRED/ALFRED) and enumerates the exact payload: latest print, revisions, surprise, next release date, 12-obs series. It also distinguishes itself from the generic sibling by noting it is 'the same shape as /v1/econ/:series bound to initial-claims,' so an agent can tell it apart from econ_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 'same shape as econ_series bound to initial-claims' clause makes clear this is the convenience binding for this specific series, which is strong context. It does not, however, state any when-not condition or explicitly route the agent away from econ_series when the generic form would suffice.

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

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

With no annotations, the description carries the full burden and does well: it discloses data provenance (FRED/ALFRED), the revision-handling behavior ('revisions never pose as print-day numbers'), the surprise baseline selection logic (market-implied with a trend-model fallback), and the access cost/mechanism ('$0.02 via x402'). It omits error states, rate limits, and freshness/caching behavior, so it is strong but not exhaustive.

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

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

Front-loaded with the one-line summary, then a detail sentence, then the HTTP/price/docs footer. It is slightly repetitive ('Nonfarm payrolls (BLS, monthly): latest print...' restated as 'Latest Nonfarm payrolls print from the BLS...'), but every element is substantive and it is appropriately sized for its output richness.

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

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

There is no output schema and no annotations, so the description must cover the return payload itself — and it does, enumerating first-release vs latest value, revised flag, surprise vs labeled expectation, next release date, and a 12-observation mini-series, plus source, cost, and endpoint. Nothing needed to call or interpret the tool 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?

Zero parameters, so the schema carries no semantics and the description does not need to document inputs. Baseline for a 0-param tool is 4; the description accurately implies a no-argument call.

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

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

States a concrete resource and source: 'Nonfarm payrolls (BLS, monthly)' with verb-like scope ('latest print, revisions, surprise'). It explicitly positions itself against its closest sibling by noting it is 'Same shape as /v1/econ/:series bound to payrolls', so an agent can tell it apart from the generic econ_series and the other econ_series_* bindings.

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 makes clear what the tool is (the payrolls binding), which implicitly routes the agent, but it never states when to choose this over econ_series, econ_calendar, or econ_dashboard, nor any exclusions or prerequisites. Usage is left to inference from the content list.

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

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

No annotations exist, so the description carries the full behavioral burden. It does usefully disclose that revisions are flagged and never presented as print-day values, and that surprise is expectation-baselined (market-implied when a matching market exists, else trend-model) — strong semantic transparency. However it is silent on read-only/auth characteristics, rate limits, and freshness/caching, which for an unannotated tool leaves real gaps.

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

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

Front-loaded with the one-line essence (indicator, source, cadence, contents) followed by a single detail sentence and a metadata footer. Dense but every clause adds factual content, and the HTTP/price/docs trailer is clearly delimited.

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

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

With no output schema and no annotations, the description must describe the return payload, and it does: first-release vs latest, revised flag, expectation-baselined surprise, next release date, and a 12-observation series. The main omission is any choice guidance relative to near-identical sibling indicator tools.

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 declares zero parameters, so there is nothing for the description to disambiguate; the 0-parameter baseline of 4 applies. The description correctly implies no inputs 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?

Names a specific resource (PCE inflation from BEA via FRED/ALFRED) and enumerates the exact contents: latest print, revisions with a revised flag, surprise, next release date, and a 12-observation mini-series. It identifies itself as the pce-inflation binding of /v1/econ/:series, but never distinguishes itself from the closely-named sibling econ_series_core-pce (core vs headline PCE), leaving a real ambiguity.

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

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

No when-to-use guidance, no prerequisites, and no named alternatives. The sibling list contains econ_series, econ_series_core-pce, and econ_series_cpi, yet the description gives no rule for choosing this bound endpoint over the generic series tool. Usage is only implied by the resource 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?

With no annotations, the description carries the full burden and does meaningful work: it names the source (Census via FRED/ALFRED), the first-release-vs-latest distinction with a revised flag, the surprise methodology (market-implied vs trend-model), the next release date, and a 12-observation mini-series. It omits auth, rate-limit, and error behavior, but for a read-only data fetch this is substantive disclosure.

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

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

Purpose is front-loaded in the first clause, then the payload is enumerated compactly. The trailing bracketed HTTP/price/docs line is dense metadata rather than prose waste. Minor restatement of 'Advance retail sales' between the first two clauses is the only redundancy and it does not hurt retrieval.

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

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

For a zero-parameter read tool with no output schema and no annotations, the description is sufficient: it explains the data source, the fields returned (first-release, latest, revised flag, surprise, next release date, mini-series), and the surprise methodology. Nothing needed to call it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no schema-level parameter meaning the description needs to supplement. The description correctly focuses on output content rather than inventing 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?

States a specific verb+resource: 'Latest Advance retail sales print from the Census via FRED/ALFRED.' The series binding ('bound to retail-sales') distinguishes it cleanly from sibling econ_series_* tools like core-cpi, payrolls, or unemployment without needing to open any schema.

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

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

Usage is only implied via 'Same shape as /v1/econ/:series bound to retail-sales,' which tells the agent this is the retail-sales specialization of the generic series tool. There is no explicit statement of when to pick this over econ_series or the other series variants, and no 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 no annotations, the description carries the load and does well: it discloses the data source (Fed via FRED/ALFRED), that revisions are explicitly flagged and 'never pose as print-day numbers', how surprise is computed (market-implied vs trend-model fallback), and the daily release cadence. It omits auth/rate-limit behavior beyond the x402 price note.

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

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

Front-loaded with the resource and scope, and the payoff (revisions, surprise, next release, mini-series) follows immediately. Slightly dense with a mild restatement of 'latest 10-year Treasury yield print' across the first two clauses, but no filler sentences.

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?

Without an output schema or annotations, the description must describe the return surface, and it does: latest print, revision flag semantics, surprise baseline, next release date, and a 12-observation series. Only minor gaps remain (no error/pagination or auth detail), which is sufficient for a fixed no-arg read.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly adds no parameter information because none exists, and additionalProperties:false confirms a fixed no-arg call.

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

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

States a specific resource ('10-year Treasury yield (Fed, daily)') and the exact payload contents: latest print, revisions, surprise. It also distinguishes itself from the generic sibling by noting it is the '/v1/econ/:series' shape 'bound to treasury-10y', so an agent can tell it apart from econ_series and econ_series_treasury-2y.

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 binding to treasury-10y plus 'daily' cadence makes the use context clear, and the reference to the generic /v1/econ/:series endpoint implies when this specialized variant applies. However, it never explicitly states when to prefer this over econ_series or the 2y sibling, so no exclusion guidance is 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?

With no annotations, the description carries the burden and mostly delivers: it discloses revision handling ('revisions never pose as print-day numbers'), the surprise methodology (market-implied when a matching prediction market exists, else trend-model), daily cadence, and even the $0.02 x402 price. It stops short of auth/payment mechanics and rate-limit 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?

Dense but front-loaded: the first clause states the resource and the payload set, then detail follows. The first phrase ('latest print, revisions, surprise') is partially restated in the next sentence, a small redundancy, but the HTTP/price/docs footer is compact and useful.

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

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

With no output schema and no annotations, the description compensates by enumerating the return fields (first-release, latest, revised flag, surprise, next release, 12-point series) in enough detail to know what comes back. Auth/payment flow and rate-limit context are the remaining 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?

Zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. Schema coverage is 100% and additionalProperties=false, so no hidden inputs 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?

Names a specific verb+resource: the latest 2-year Treasury yield print from the Fed via FRED/ALFRED, with a precise payload list (first-release vs latest, revised flag, surprise, next release, 12-obs mini-series). It differentiates from the generic econ_series sibling by stating it is the treasury-2y-bound shape, and from econ_series_treasury-10y by naming the 2-year tenor.

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

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

Usage is implied by the resource (fetch the 2y Treasury series) but the description never says when to prefer it over econ_series or econ_series_treasury-10y, nor any exclusions. The 'same shape as /v1/econ/:series bound to treasury-2y' line hints at the relationship without resolving which to call.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the FRED/ALFRED sourcing, the first-release-vs-latest/revision-flag semantics ('revisions never pose as print-day numbers'), how surprise is derived (market-implied vs trend-model), and the cost ($0.02 via x402). It stops short of describing rate limits, auth requirements, or failure modes.

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 lead sentence ('latest print, revisions, surprise') is immediately restated and expanded in the second sentence, creating redundancy. The HTTP/pricing footer is compact and useful, but the description could be tightened without losing content.

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

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

For a zero-parameter tool with no output schema and no annotations, the description enumerates the returned fields (first-release, latest, revised flag, surprise vs labeled expectation, next release date, 12-observation series) so an agent knows what to expect. The reference to '/v1/econ/:series' shape is slightly circular for a caller without that doc, but the explicit field list compensates.

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

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

The tool takes zero parameters and the schema is an empty object, so there is nothing to document beyond confirming the no-arg nature; baseline 4 applies. The description correctly implies no filtering inputs 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?

States a specific verb+resource ('Unemployment rate (BLS, monthly)') and enumerates exactly what the tool surfaces: latest print, revisions, surprise, next release date, mini-series. It clearly distinguishes itself from the generic econ_series sibling by noting it is 'bound to unemployment' and from other econ_series_* siblings by naming the BLS unemployment 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 note 'Same shape as /v1/econ/:series bound to unemployment' implies this is the unemployment specialization of the generic series endpoint, which is useful routing context. However, it never explicitly states when to prefer this tool over econ_series or how it differs from other econ_series_* variants, leaving the agent to infer usage from the name.

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

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

No annotations exist, so the description carries the full burden. It does disclose the data scope (only resolved markets are aggregated), the HTTP method, and the $0.05 x402 cost with a docs link, which is useful operational context. However it never states that this is a read-only aggregation, nor anything about latency, pagination, or freshness of the aggregates.

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

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

The opening sentence front-loads the essence well, but the second sentence is long and repeats items already named ('how often the model beat the market (hit rate)' re-states hit rate, 'a model calibration curve' re-states calibration). The trailing bracket is dense but functional; overall it is moderately verbose rather than tight.

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

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

With no output schema, the description does a fair job naming the returned aggregates (hit rate, edge captured, calibration curve, per-hazard breakdowns), which covers the return-value burden. But both input parameters are left unexplained, and nothing routes the agent away from the overlapping edge_calibration sibling, so the picture is incomplete for a two-param data 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 0%, so the description must compensate, and it largely does not: neither 'window' (required, default 90) nor 'min_divergence' is explained anywhere. Worse, it highlights 'model_label' as a meaningful selector even though model_label is absent from the input schema, which can mislead the agent about what it can pass in.

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

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

The description gives a concrete verb-of-effect (aggregates stored edge signals) and a precise resource (historical backtest performance of the edge signal), enumerating the outputs: hit rate, edge captured, calibration curve, per-hazard breakdowns. It is clear what the tool does, but it never distinguishes itself from the very similar sibling edge_calibration, which also deals with calibration.

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 statement and no mention of the obvious alternative edge_calibration. The agent is left to infer that this is for evaluating realized model performance from the phrase 'whose markets have resolved', but nothing states when this should be chosen over a sibling.

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

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

With no annotations, the description carries the full load, and it does substantial work: it discloses that the tool is free, has no parameters, that the allowlist is schedule-derived and never hand-edited, that entries are per model_version using current-version evidence only, and that older versions remain visible as labeled history. It omits auth/x402 mechanics beyond 'price free' and says nothing about rate limits or refresh cadence.

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

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

The description is dense but front-loaded, leading with the core noun (per-class edge-signal calibration) before details. Some phrasing is promotional ('the gate deciding what we sell') and the trailing HTTP/docs line is boilerplate, but overall each sentence adds substance without excessive padding.

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

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

There is no output schema, so the description must describe the return, and it does so explicitly (resolved-signal count, predicted-vs-realized by decile, allowlist flag, version history). Combined with the free/allowlist behavioral context, an agent has enough to call and interpret it; only sibling routing and refresh timing are unaddressed.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline for a no-param tool is 4. The description correctly implies a parameterless, whole-table read rather than a query interface.

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

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

The description states a specific resource and output clearly: a per-class edge-signal reliability table with resolved-signal counts, predicted-vs-realized by decile, and allowlist status. It is clear what the tool does, but it never names or contrasts itself with adjacent siblings like edge_detail, edge_backtest, or probability_venue-calibration, so differentiation is left to inference.

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

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

There is a soft usage cue ('Free forever so you can judge signal quality before paying for signals') implying this is an evaluation/audit step. However, there is no explicit when-to-use vs when-not, no mention of how it relates to edge_backtest or edge_detail, and no prerequisites spelled out.

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

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

With no annotations, the description carries the full burden and does disclose meaningful traits: a 31-day horizon cap, a labeled method, station-vs-point coverage limits with the INVALID_PARAMS failure mode, NWS-derived sourcing, market cross-referencing, and a $0.05 x402 price. It omits return-value shape and any auth/rate-limit detail, keeping it below a 5.

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 key scope statement is front-loaded and the sentences are dense but purposeful, covering deliverable, coverage limits, and cross-referencing. The trailing HTTP/price/docs block is useful metadata rather than filler, though the whole is packed tightly enough to be a little heavy.

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

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

For an 8-parameter, annotation-free tool with no output schema, the description covers coverage/behavior/pricing well but should explain the response shape (probability value, method label) since no output schema exists. Half the parameters and the return format are left to inference.

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

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

Schema description coverage is only 38%, so the description must compensate, and it partially does by tying condition values (temp_above/below, precip, wind, named storm) to coverage behavior and clarifying window_stat max/min semantics. It adds nothing about lat/lon, city, threshold units, or the window date bounds beyond what the schema already states.

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

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

The description states a specific deliverable – the model's probability that a weather condition occurs in a future window – and scopes it (temp at covered stations, precip/wind at any US point). It implicitly distinguishes itself from the market-based siblings like edge_weather-markets by noting it cross-references, rather than returns, market data. It stops short of naming an alternative tool explicitly.

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

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

It gives real usage constraints (temp events only work at model-covered stations and otherwise return INVALID_PARAMS; precip/wind/named-storm work for any US point), which tells the agent when a call will succeed. However, it never routes the agent to a specific alternative when the condition is unsupported, so the 'vs alternatives' guidance remains implied.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose real behavioral context: it is a paid GET endpoint ($0.1 via x402), read-oriented, and enumerates what the payload contains including the half-Kelly sizing hint and model-labeling risk notes. It omits things like freshness/caching or latency, keeping it short of a 5.

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

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

Front-loaded with the core purpose, then the enumerated payload, then the slug-source pointer, with endpoint metadata quarantined in a bracketed trailer. Dense but every clause earns its place; only the metadata bracket is slightly noisy.

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 must describe returns and it does so adequately (probability, distribution, divergence history, sizing, risk notes). Combined with the slug-source routing and endpoint/pricing metadata, an agent has enough to call it correctly, though freshness and error behavior remain unspecified.

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

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

Schema description coverage is 0% and the single slug parameter has only a regex pattern in the schema. The description compensates by directing the agent to /v1/edge/weather-markets as the source of valid slug values, giving meaningful semantic guidance 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?

States a specific verb+resource: a deep model-vs-market breakdown for a single weather market, enumerating the concrete outputs (model probability with discretized distribution, divergence history, half-Kelly sizing hint, risk notes). This clearly distinguishes it from sibling edge_weather-markets, which lists markets rather than detailing one.

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

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

Explicitly routes the agent to edge_weather-markets ('Find slugs via /v1/edge/weather-markets') to obtain the required slug, which clarifies the workflow relative to that sibling. It does not state when NOT to use it (e.g. vs edge_weather-markets-delayed), so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does well: it discloses that results are ranked by divergence with direction, that confidence derives from ensemble spread, that liquidity is included, that parse_coverage reports catalog coverage, and that signals only emit for classes passing a public calibration gate. It also exposes the transport (HTTP GET) and cost ($0.15 x402), which is useful behavioral context.

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

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

The core purpose is front-loaded in the first sentence, followed by supporting detail, with transport metadata bracketed at the end. It is dense but every sentence carries information; no filler.

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

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

For a tool with no output schema and no annotations, the description is reasonably complete: it explains what is returned (divergence, direction, confidence, liquidity, parse_coverage) and the gating condition. The remaining gaps are the undocumented parameters and the absence of alternative-tool routing.

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

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

Schema description coverage is only 50%, so the description should compensate for undocumented parameters, but it adds no meaning for limit, min_divergence, or region beyond the schema. Only hazard carries a schema-level description. The ranking-by-divergence phrasing loosely touches min_divergence but never defines it.

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

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

The description states a precise verb and resource: it compares the model's event probability against the market-implied probability for weather-linked prediction markets, ranked by divergence. An agent immediately knows the deliverable (divergence signals). It does not, however, explicitly differentiate itself from close siblings like edge_weather-markets-delayed, leaving the real-time-vs-delayed distinction to inference.

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

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

There is no explicit when-to-use guidance, no statement of when NOT to use it, and no named alternative. The calibration-gate sentence describes an emission condition rather than helping an agent choose this tool over edge_calibration, edge_detail, or edge_weather-markets-delayed.

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

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

With no annotations, the description carries the full load and does so well: it discloses the 15-minute staleness, the free/x402 pricing, the calibration gate that suppresses signals for uncalibrated classes, and the ranking/return fields (divergence, direction, model confidence from ensemble spread, liquidity, parse_coverage). It leaves unaddressed error behavior and result cutoff semantics, but the operational profile is unusually well documented.

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

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

Front-loads the core purpose, then layers staleness, pricing, and gating in tight sentences; the trailing HTTP/pricing/docs block is compact and useful. The only blemish is the truncated leading fragment ('...weather p…'), likely an artifact, which slightly muddies the opening.

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-annotation, no-output-schema tool it covers purpose, routing, staleness, pricing, gating, and the main response fields, so an agent has enough to call it correctly. Pagination behavior and empty-result handling are the notable omissions, which keep it short of a 5.

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

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

Schema coverage is 50% — hazard and region are documented in the schema, while limit and min_divergence rely on their names and numeric bounds. The description adds no parameter-level meaning (e.g., how limit interacts with ranking, or what min_divergence filters on), so it neither compensates for the gap nor detracts.

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

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

States a specific verb+resource (compares weather-model event probability vs market-implied probability across weather-linked prediction markets) and explicitly distinguishes itself from its closest sibling by naming the /v1/edge/weather-markets endpoint as the realtime counterpart. An agent can route between the two without opening either schema.

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

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

Explicitly frames the selection condition: this is the free, 15-minute-stale variant, and 'Use the paid endpoint for realtime data.' It also notes the emission gate (only calibrated market classes). It stops short of stating when not to use it beyond the free/realtime tradeoff, but the routing guidance 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?

With no annotations, the description carries the full burden; it usefully discloses that this is a paid, read-only HTTP endpoint ($0.02 via x402) and gives the docs URL, which helps an agent understand cost/auth. It stops short of describing default behavior when no filters are applied, the recency window, or pagination beyond the schema's limit.

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

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

It is front-loaded with purpose, then returned fields, then sort/filter behavior, then endpoint metadata. Dense but every clause carries information; the bracketed HTTP/price block is compact and clearly delimited.

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, yet the description enumerates the returned record shape (vendor, agency/sub-agency, value, NAICS, start date, place of performance), which is exactly what an agent needs. It omits default query behavior and the relationship to the _changes/_delta siblings, but is otherwise sufficient for calling 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 only 50% (naics, min_value_usd, and limit are undocumented in the schema), and the description compensates by naming every filterable dimension including NAICS and minimum value. It adds little on syntax, but it closes most of the coverage gap.

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

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

The description names a specific verb+resource (federal contract awards from USAspending) and enumerates the returned record fields, so an agent knows exactly what data comes back. It does not, however, distinguish this tool from its near-identical siblings gov_contracts-awards_changes and gov_contracts-awards_delta.

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 lists the available filters (vendor, agency, NAICS, minimum value, date) and states records are sorted by value, which implies how to narrow a query, but it never says when to reach for this tool over the _changes or _delta variants. Usage is inferable rather than explicit.

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

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

With no annotations, the description carries the burden and does so well: it discloses the exact return shape (changed_count, next_cursor, as_of, no rows), the cost model (free via x402), and the HTTP method and path. It does not discuss auth setup beyond the x402 price note or any rate limits, which is the only remaining gap.

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

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

Front-loads the value proposition and return shape, then usage routing, then compact HTTP metadata. Every element earns its place, though 'Free:' is repeated at the start and again in the price tag, a minor 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?

There is no output schema, so the description must explain returns, and it does so precisely (the three fields and the absence of rows). Combined with the trivial single-parameter schema, an agent has everything needed to call and interpret this 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% and the schema already explains 'since' as an opaque cursor from a previous next_cursor with bootstrap-on-omit semantics. The description adds no parameter-level detail beyond that, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('count of federal contract awards changed since your cursor') and immediately scopes it as a probe that returns no rows. It explicitly distinguishes itself from the paid sibling by naming when the delta should be called instead, so an agent can tell the two apart without opening either schema.

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

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

Gives explicit when-to-use guidance ('poll hourly for $0') and a clear escalation condition ('call the paid delta only when changed_count > 0'), naming the alternative sibling by implication. Nothing about selection between this and gov_contracts-awards_delta is left to inference.

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

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

No annotations, so the description carries the full burden and does well: it discloses delta semantics, that cursors are stable across restarts, the bootstrap path, that the response includes changed_count and a new next_cursor, and the $0.01 x402 price. It omits any rate-limit or cursor-expiry behavior, keeping it short of a 5.

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?

Dense but front-loaded, with the core delta semantics and bootstrap instruction first, followed by pricing and docs. The opening fragment "delta of /v1/contrac." reads like truncated boilerplate and costs a little clarity.

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

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

For a one-param delta tool with no output schema, the description covers what an agent needs: how to call it, how to bootstrap, what comes back (awards plus changed_count and next_cursor), and how to avoid paying unnecessarily. Nothing material is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds value beyond the schema by explaining the parameter's role in the cursor loop (feed back next_cursor, omit once to bootstrap) and asserting cursor stability across restarts.

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

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

States a specific verb/resource/scope: only federal contract awards changed since a cursor, keyset delta of /v1/contracts/awards. It explicitly distinguishes itself from the sibling changes endpoint and from the full awards list, so an agent can pick it without opening a schema.

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

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

Gives explicit operating instructions: pass since=<next_cursor from your last call>, omit since once to bootstrap, and poll the free sibling /v1/contracts/awards/changes for counts so you "pay only when there is something to fetch." When-to-use and cost-avoidance guidance are both present.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the exact diff categories returned and that CIKs may be zero-padded, and the HTTP/price footer adds operational context, but it never explicitly confirms this is a read-only, side-effect-free operation, nor mentions auth, rate limits, or behavior when a prior quarter is missing.

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

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

Three sentences, front-loaded with the operation, then the parsed outputs, then the CIK-format caveat. Tight and waste-free, though the bracketed endpoint/price/docs footer is metadata rather than description.

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

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

With no output schema and no annotations, the description does the heavy lifting by enumerating what the diff returns and how CIK formatting is handled. Remaining gaps are edge-case behavior (no prior quarter, unparsable filing) rather than anything essential 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?

Schema coverage is only 50%: quarter is documented inline ('Defaults to the latest filed quarter'), and the description adds real meaning for cik by noting zero-padding is tolerated. That covers the gap left by the bare cik string pattern, though it stops short of any syntax help beyond padding.

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

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

States a specific verb and resource: 'diffs the latest quarter against the prior one' for a fund's 13F-HR information tables. The output enumeration (new positions, exits, increases, decreases, top-10 concentration) makes it clearly distinct from siblings like gov_edgar-filings-search or gov_edgar-insider.

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 use case (quarter-over-quarter institutional position analysis) but never states when to prefer this over alternates or what prerequisites apply. No sibling routing or when-not guidance is given, so an agent must infer the fit from the purpose statement alone.

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

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

No annotations exist, so the description carries the full behavioral burden. It does disclose meaningful traits: classification is deterministic, output includes a bounded two-sentence summary plus the filing URL, and there is a per-call price ($0.02 via x402) plus an HTTP endpoint. It says nothing about read-only safety, rate limits, or pagination behavior, so it is adequate but incomplete.

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 plus a bracketed endpoint/pricing/docs line; the core purpose is front-loaded and each sentence does useful work. The metadata bracket adds length but delivers concrete access details, so the structure holds up well.

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 convey return content, and it does describe the summary and filing URL. However, it omits the required 'limit' semantics, pagination/ordering, and any auth or rate-limit context, leaving gaps for a 4-parameter query tool.

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

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

Schema description coverage is only 25% (only 'since' is documented), so the description must compensate. It covers three of four params semantically (ticker, type, date) and helpfully maps Item numbers to event-type enum values (5.02 → leadership_change, etc.), but it never explains the required 'limit' parameter or its 1–50 bound.

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

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

The description states a specific resource (SEC 8-K corporate events), mechanism (deterministic Item-number classification) and output (two-sentence extractive summary + filing URL). It is clear what the tool does, but it never differentiates itself from the many sibling specializations (gov_edgar-events_acquisitions, _bankruptcy, _results, etc.), leaving the agent to infer that this is the catch-all event feed.

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 'Filter by ticker, event type, or date' implies the intended usage pattern but gives no explicit when-to-use guidance. There is no statement about when this general feed should be chosen over the type-specific siblings, and no prerequisites or exclusions are provided.

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

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

With no annotations provided, the description carries the full burden and does meaningful work: it names the HTTP method, discloses a per-call cost ($0.02 via x402), and describes the payload contents (structured JSON with extractive summaries and filing links). It omits freshness/latency of 'latest' and any rate-limit or pagination behavior, which would matter for a paid feed.

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?

Purpose is front-loaded and the metadata bracket is compact, but the first two sentences restate the same idea ('Latest 8-K events ... as structured JSON' / 'Latest 8-K filings ... parsed into structured JSON') using nearly identical wording. Trimming one sentence would lose no 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 three-parameter tool with no annotations and no output schema, the description gives a fair picture of the returned data and its relationship to the parent feed, but leaves the 'ticker' filter and the meaning of 'limit' entirely undocumented. The gap is noticeable even though return-value detail is not strictly required absent an output schema.

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

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

None of the three parameters are mentioned in the description. Only 'since' has a schema description (33% coverage); 'limit' and especially 'ticker' rely on bare type/pattern constraints with no explanation of what they filter. With low coverage the description was expected to compensate and does not.

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

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

States a specific verb+resource and scope: 'Latest acquisition and disposition 8-K events', narrowed to 'Item 2.01' filings. It explicitly differentiates itself from the umbrella feed by noting it is 'pre-filtered to Item 2.01 events' and shares the shape of /v1/edgar/events, so an agent can separate it from the bankruptcy, leadership-change, and results siblings without opening any schema.

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

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

The phrase 'pre-filtered to Item 2.01 events' paired with the reference to /v1/edgar/events clearly contextualizes when this variant is the right pick over the generic events endpoint. It stops short of explicit when-not guidance (e.g. 'for bankruptcy or leadership changes, use the sibling endpoints'), so it is clear context without 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 no annotations, the description carries the full burden and does a decent job: it discloses the return shape (structured JSON with extractive summaries and filing links), and adds operational context the schema cannot convey (HTTP GET, $0.02 x402 payment/auth requirement, docs URL). It stops short of pagination, ordering, or rate-limit 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?

Purpose is front-loaded in the first sentence, followed by category precision and return-shape context; the bracketed HTTP/pricing/docs note is compact. Three sentences, all earning their place, though the first and second sentences partially repeat the 'structured JSON' idea.

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

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

There is no output schema, and the description does describe the return shape ('same shape as /v1/edgar/events', summaries and filing links), which covers the return-value burden. However, for a 3-parameter tool with only one documented parameter, the filtering inputs (limit, ticker) remain unexplained, leaving a gap.

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

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

Schema description coverage is only 33% (only 'since' is documented), and the description supplies no meaning for 'limit' or 'ticker'. With low coverage the description is expected to compensate, and it does not.

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

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

States a specific verb+resource ('Latest bankruptcy and receivership 8-K events as structured JSON') and pins the exact filing category (Item 1.03). It clarifies its relationship to the parent endpoint ('pre-filtered to Item 1.03 events'), distinguishing it from gov_edgar-events and the other gov_edgar-events_* subtype siblings without needing the schema.

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

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

The phrase 'Same shape as /v1/edgar/events, pre-filtered to Item 1.03 events' implies you should use this instead of the general events endpoint when you only want bankruptcy/receivership filings, but it never states an explicit when-to-use condition or exclusion.

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

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

No annotations are provided, so the description carries the full burden, and it does: discloses the return shape (changed_count, next_cursor, as_of only, no rows), the pricing model (free via x402), auth/cost mechanics, and the recommended polling cadence. Rich behavioral disclosure for a read-only probe.

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

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

Front-loaded with the core purpose and scope in the first sentence, followed by the return contract and the polling strategy. The bracketed HTTP/price/docs line is useful routing metadata rather than filler; slight redundancy in repeating 'free' but overall tight.

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

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

No output schema exists, and the description explicitly enumerates the returned fields and states that no rows are returned, so the agent knows exactly what to expect. Combined with cost, cadence, and endpoint docs, nothing needed to invoke correctly is missing.

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

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

Schema coverage is 100% and already documents `since` as an opaque cursor with bootstrap semantics. The description reinforces this by describing the return of next_cursor and the free/paid split, giving the agent enough to chain calls, though it adds little syntax beyond what the schema states.

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

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

States a specific resource (8-K filings changed since cursor) and verb (count), and explicitly positions itself against its sibling gov_edgar-events_delta as the 'free polling probe.' An agent can distinguish it from the paid delta without reading either schema.

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

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

Explicitly prescribes the workflow: poll hourly for $0 and only call the paid delta when changed_count > 0. Names the alternative (paid delta) and the exact condition that selects it. Nothing is left to inference.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the paid model ($0.01 via x402), that cursors are stable across restarts, that the response carries changed_count plus a new next_cursor, and a cost-avoidance polling strategy. It does not cover failure modes (stale/invalid cursor) or rate limits, so not quite maximal.

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

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

Front-loaded with the core purpose, then bootstrap/cursor mechanics, then the HTTP/pricing trailer. Slightly redundant in restating the endpoint twice ('delta of /v1/edgar/events' then 'Keyset delta of /v1/edgar/events'), but every remaining 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?

For a one-param tool with no annotations and no output schema, the description covers bootstrap behavior, delta semantics, cursor persistence, and names the returned fields (changed_count, next_cursor), which substitutes adequately for the missing output schema.

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

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

Schema coverage is 100% and the single schema description already says 'Opaque cursor from a previous next_cursor; omit once to bootstrap'. The description's guidance ('since=<next_cursor from your last call>', 'Omit since once to bootstrap') largely restates the schema, so 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?

States a specific verb+resource (delta of 8-K filings from /v1/edgar/events) and immediately scopes it as 'only the 8-K filings changed since your cursor'. The parenthetical '(delta of /v1/edgar/events)' makes the relationship to the full endpoint and to sibling tools 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?

Explicit operational contract: pass since=<next_cursor from your last call>, omit since once to bootstrap, and poll the free sibling /v1/edgar/events/changes for counts before paying. Names both the required flow and the cheaper alternative, so an agent knows exactly when to call this vs the sibling.

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

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

With no annotations, the description carries the burden and does disclose useful behavior: GET semantics, the $0.02 x402 payment requirement, structured JSON output with extractive summaries and filing links, and a docs URL. It omits rate limits, pagination, and freshness/latency caveats that matter for a paid feed.

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

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

The first two sentences are largely redundant restatements of the same point (latest Item 5.02 8-K events as structured JSON), and the trailing bracketed transport/pricing block is crammed on. The core idea is front-loaded, but roughly a third of the text earns no additional meaning.

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

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

No output schema and no annotations, so the description must do the work; it partially does by describing the return shape (structured JSON, extractive summaries, filing links) and the payment/docs details. However, with 3 parameters and weak schema coverage, the filter and paging behavior is left unexplained, which is a meaningful gap for a parametrized feed.

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

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

Schema coverage is only 33% (only "since" is documented). The description gives no explanation of any of the three parameters — notably "limit" (required, max 50) and "ticker" (put/call syntax, max length 6) are undocumented in both schema and description, so the reader cannot infer filtering or paging 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 names a specific resource (latest 8-K Item 5.02 executive/board leadership-change events) with a clear verb and scope, and explicitly positions itself as a pre-filtered slice of /v1/edgar/events. An agent can distinguish it from the many sibling event-type tools (acquisitions, bankruptcy, restatement, etc.) without opening a schema.

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

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

"Pre-filtered to Item 5.02 events" and "same shape as /v1/edgar/events" tell the agent when this tool is the right pick versus the unfiltered parent. There is no explicit when-not-to-use or named alternative tool, but the selection condition 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?

With no annotations, the description carries the full burden. It usefully discloses the return content (structured JSON with extractive summaries and filing links) and operational facts (HTTP GET, $0.02 via x402 pricing, docs link), which is real value beyond a bare name. However it omits recency/pagination semantics implied by 'Latest', auth/permission requirements, and how the coverage window is bounded.

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, purpose front-loaded, and the bracketed HTTP/pricing/docs footer is compact. There is mild redundancy ('structured JSON' appears twice) but 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?

No output schema exists, and the description partially compensates by pointing to the shared /v1/edgar/events shape and listing what each record carries. It falls short for a 3-parameter, annotation-free tool: the required limit and the ticker filter are never explained, leaving an agent to guess at core invocation behavior.

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

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

Schema coverage is only 33% (just the 'since' filter), and the description mentions no parameters at all. The required 'limit' (with min 1 / max 50) and the 'ticker' filter are documented nowhere in either schema or description, so the description does not compensate for the coverage gap.

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

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

The description states a specific verb and resource ('Latest material definitive agreement 8-K events as structured JSON') and pins the exact classification (Item 1.01). It explicitly differentiates itself from siblings by noting it is 'Same shape as /v1/edgar/events, pre-filtered to Item 1.01 events,' so an agent can separate it from the other gov_edgar-events_* category 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 makes the selection condition clear: use this when you want Item 1.01 material-agreement events specifically, versus the unfiltered gov_edgar-events or the other category variants. It stops short of explicitly naming a sibling alternative or stating when-not to use it, so it lands just below the top.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses the read-only HTTP GET nature, that the endpoint is paid ($0.02 via x402, an auth/payment precondition), and that output includes extractive summaries and filing links. It omits pagination/ordering behavior and rate-limit context.

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

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

Three tight sentences, front-loaded with what the tool returns and the key Item 8.01 filter, followed by a shape reference. The trailing bracket packs the HTTP route, price, and docs URL compactly without diluting the core description.

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

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

For a read-only list tool with no output schema, the description adequately covers the return payload (structured JSON, extractive summaries, filing links) and points to the /v1/edgar/events shape. The main shortfall is that 'limit' and 'ticker' filtering semantics are left to the schema, whose coverage is low.

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

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

Schema description coverage is only 33%: only 'since' is documented ('Only events filed on/after this date'). The description adds no meaning for 'limit' (default 20, max 50) or 'ticker' (max 6 chars), so the two undocumented parameters remain opaque to the agent, and the description does not compensate for that gap.

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

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

States a precise verb+resource: 'Latest 8-K filings classified as other material event (Item 8.01) ... parsed into structured JSON.' It explicitly differentiates itself from the base sibling gov_edgar-events by noting it is 'pre-filtered to Item 8.01 events,' so an agent can select it over the other gov_edgar-events_* variants without opening a schema.

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

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

Gives clear context for use — you call this when you want Item 8.01 'other material event' filings rather than all events. It names the base /v1/edgar/events shape as the reference point, which helps routing, but stops short of explicitly stating when NOT to use it (e.g., use the base tool for unfiltered events, other variants for different Item types).

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

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

With no annotations, the description carries the full burden. It usefully discloses the output shape (structured JSON with extractive summaries and filing links), the HTTP method/endpoint, and the $0.02 x402 price — real behavioral context. It stops short of auth requirements, pagination, result freshness, or rate limits, so gaps remain.

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

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

Front-loaded with the resource and scope, and the bracketed metadata line separates operational facts. Minor redundancy: 'Latest' and 'structured JSON' each appear twice, and the first two sentences restate the same idea.

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

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

With no output schema, the description does helpfully sketch the return payload, but for a 3-parameter tool it leaves limit/ticker semantics and processing/timeliness unaddressed. Adequate but not complete for correct invocation.

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

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

Schema description coverage is only 33% (only 'since' is documented). The description never mentions limit (required, max 50), ticker, or how filtering combines, so it does nothing to compensate for the two undocumented parameters.

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

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

States a specific resource (Regulation FD / Item 7.01 8-K events) with the verb 'latest... as structured JSON' and explicitly distinguishes itself from the parent 'Same shape as /v1/edgar/events, pre-filtered to Item 7.01 events.' An agent can tell it apart from siblings like gov_edgar-events_acquisitions or _bankruptcy without opening any schema.

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

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

Implies the use case (you want only Reg FD disclosures rather than all events) by referencing the parent endpoint and the Item 7.01 filter, but never states when to prefer this over the parent or the other event-type siblings, and gives no exclusions or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden and discloses meaningful traits: it is an HTTP GET read endpoint, costs $0.02 via x402, exposes documentation, returns structured JSON with extractive summaries and filing links, and matches the /v1/edgar/events shape. It omits pagination behavior, rate limits, and authentication specifics beyond the x402 payment note, keeping it below 5.

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

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

The first sentence front-loads the resource and purpose, the second adds classification detail, and the third routes the agent to the generic sibling. The HTTP/pricing/docs bracket is compact reference metadata rather than prose bloat, so 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?

With no output schema, the description usefully conveys return content (structured JSON, summaries, links) and the Item 4.02 filter, which helps an agent understand results. However, it leaves key invocation details unexplained, notably the behavior of the required 'limit' and optional 'ticker' parameters and pagination semantics, making it only minimally complete.

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

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

Schema description coverage is only 33% (only 'since' is documented in the schema), and the description adds no meaning for 'limit,' 'ticker,' or even 'since.' It fails to compensate for the low coverage, so an agent must reverse-engineer the required limit and optional ticker filters entirely from bare schema constraints.

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

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

States a specific resource and scope: 'Latest restatement and non-reliance 8-K events' filtered to 'Item 4.02,' which distinguishes it from the broad gov_edgar-events sibling and from other event-specific siblings like bankruptcy or acquisitions. An agent can identify the exact data slice without opening the schema.

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

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

Provides clear routing context by naming the generic endpoint it mirrors ('Same shape as /v1/edgar/events, pre-filtered to Item 4.02 events'), implying when to choose this tool over the unfiltered one. It stops short of an explicit when-not or a direct 'use X instead' instruction, so it does not reach 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?

No annotations are provided, so the description carries the full burden. It does disclose the return shape (structured JSON with extractive summaries and filing links) and the pricing/auth model (GET, $0.02 via x402), which is genuinely useful. However it omits pagination, ordering, and freshness/update behavior for a 'latest' endpoint.

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

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

Front-loaded with the core purpose and appropriately brief. There is mild redundancy in restating 'Latest 8-K... structured JSON' and 'parsed into structured JSON,' but the pricing/docs footer is compact and useful.

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

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

No output schema and no annotations, so the description must stand alone; it does describe the returned payload (parsed JSON, extractive summaries, filing links), which helps. But with three parameters and undocumented limit/ticker semantics, plus no pagination or freshness detail, it is only minimally complete.

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

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

Schema description coverage is only 33% (just 'since'), and the description mentions none of the three parameters. The meaning of limit (default 20, max 50) and how ticker scopes results are left entirely to the bare schema, so the description fails to compensate for the coverage gap.

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

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

States a specific verb (returns latest results-of-operations 8-K events), the exact item classification (Item 2.02), and the output form (structured JSON). It explicitly positions itself against the sibling generic endpoint by noting it is 'pre-filtered to Item 2.02 events,' so an agent can distinguish it from gov_edgar-events and the other event-type variants.

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 line 'Same shape as /v1/edgar/events, pre-filtered to Item 2.02 events' gives clear selection context: choose this when you only want results-of-operations events. No explicit exclusions or when-not guidance is provided, but the routing context 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?

With no annotations, the description carries the full load and does well: it discloses fair-access rate limiting, normalization of hits, the fact that upstream returns no text excerpt so snippets describe the matched document, and the x402 pricing/HTTP surface. It does not state pagination or ordering behavior, keeping it short of a 5.

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 tightly-packed sentences with the core purpose front-loaded and operational metadata confined to a trailing bracket. No filler, though the bracket block is dense with pricing/endpoint detail that dilutes slightly.

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

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

No output schema or annotations exist, so the description must cover return shape — and it does, naming company, form, filing date, matched document, and archive URL, plus the snippet caveat. Missing date-filter semantics and any cap on the 20-result limit keep it from a 5.

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?

At 33% schema description coverage over 6 parameters, the description should compensate but largely does not: limit, ticker, date_from, and date_to get no added meaning. It does loosely gesture at filterable dimensions via the named result fields (company, form, filing date), but no syntax or semantics are added 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?

States a specific verb and resource — 'Full-text search over SEC filings (EDGAR FTS)' — and pins the upstream source (efts.sec.gov) plus the normalized result shape. This cleanly separates it from the event-, insider-, and 13F-oriented EDGAR siblings.

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

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

The description never says when to prefer this tool over alternatives such as gov_edgar-events or gov_edgar-watch, nor does it state prerequisites or exclusions. Only implied usage ('full-text search') is available, so the agent must infer the selection case on its own.

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

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

With no annotations provided, the description carries the burden and largely does so: it discloses the data provenance (parsed SEC Form 4 filings), the derived fields (buy/sell/award classification, 10b5-1 flags, per-filer roles, net flow), and a genuine operational trait — the endpoint is paid ($0.02 via x402) and accessed over HTTP GET. Rate limits and freshness/latency are not covered.

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

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

Front-loaded with purpose, then return-field detail, then usage, then bracketed transport/pricing metadata. Dense but each sentence carries information; the bracket line is compact and useful rather than padding.

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

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

With no output schema and no annotations, the description compensates well by enumerating the returned content (classification, plan flags, roles, aggregate flow, notable-pattern flags), so an agent knows what comes back. It is slightly incomplete on the ticker parameter's constraints and pagination/error behavior.

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

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

Schema description coverage is 67%; days and min_value_usd are documented in the schema, while ticker has none. The description mentions "for a ticker" but adds no syntax, format, or filtering semantics beyond what the schema already states, so baseline 3 applies.

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

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

States a specific verb and resource: normalized SEC Form 4 insider transactions with flow aggregates for a ticker. The domain (insider buying/selling) is inherently distinct from the gov_edgar siblings like 13f-diff and events, though no sibling is named explicitly to clinch the differentiation.

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?

"Use it to gauge insider conviction before events" gives a clear use case and timing context. There are no explicit exclusions or named alternatives (e.g., 13F for institutional flow), which keeps it below a 5.

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

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

With no annotations the description carries the full burden, and it does most of the work: it discloses the price (free via x402), the exact return shape (changed_count, next_cursor, as_of only — no rows), and a recommended polling cadence. It stops short of stating rate limits or error behavior, so it is strong but not exhaustive.

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

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

Front-loads the essential fact ('Free: count of filings...') and packs pricing, return shape, and polling policy into a tight block. The trailing HTTP/doc bracket is metadata rather than prose but is compact and standard for this tool family.

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

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

With no output schema, the description correctly compensates by naming the returned fields (changed_count, next_cursor, as_of) and the fact that no rows are returned. Combined with cost and cadence guidance, an agent has enough to call it correctly; only edge-case/error behavior is unaddressed.

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

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

Schema coverage is 50%; the `since` cursor is already documented in the schema (including the bootstrap-at-now behavior) and the `form` enum is self-describing. The description references 'your cursor' and 'next_cursor' but adds little parameter meaning beyond what the schema already states, so the baseline 3 is appropriate.

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

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

States a specific verb and resource — a count of filings of the watched form changed since the cursor — and explicitly distinguishes itself from the sibling gov_edgar-watch_delta by framing itself as the free probe that returns no rows. An agent can tell the two apart without opening either schema.

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

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

Gives an explicit operational policy: poll hourly for $0 and only call the paid delta when changed_count > 0. It names the alternative (the paid delta) and the exact condition that selects it, leaving nothing to inference.

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

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

No annotations exist, so the description carries the full load and does well: it discloses the keyset-delta semantics, that cursors are stable across restarts, what the response contains (changed_count and a new next_cursor), and the $0.01 x402 cost. It does not spell out auth mechanics beyond the x402 price line or rate limits, which keeps it short of a 5.

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?

Dense but front-loaded: the core delta behavior and cursor usage lead, with the HTTP/price/docs bracket trailing as reference metadata. Most sentences earn their place, though the endpoint/pricing bracket is somewhat boilerplate.

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 steps in to describe the return shape (changed_count plus a new next_cursor) and the bootstrap flow. For a two-parameter paid delta endpoint this is essentially complete; only auth/rate-limit detail is absent.

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

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

Schema coverage is only 50% (the 'form' enum is undocumented), but the description compensates for the important parameter by explaining the cursor's provenance and lifecycle: where 'since' comes from, that it is opaque, and that omitting it bootstraps at now. It reinforces rather than merely repeats the schema text for 'since'.

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+resource ('delta of /v1/edgar/watch/:form') and precisely scopes it: only filings of the watched form added or changed after the cursor. It distinguishes itself from the sibling gov_edgar-watch_changes by casting that one as the free count-only endpoint, so an agent can route without opening either schema.

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

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

Explicit operational guidance: pass since=<next_cursor from your last call>, omit it once to bootstrap, and poll the free sibling for counts and only pay when there is something to fetch. This is exactly when-to-use plus a named cheaper 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?

With no annotations, the description carries the full burden and does meaningfully disclose behavior: cross-source normalization into one shape, a unified severity class with stated derivation rules (Class I highest, FDA/USDA verbatim, CPSC derived from hazard language), newest-first ordering, and the HTTP/pricing/auth context (GET /v1/recalls, $0.01 via x402). It omits rate limits and error/empty-result behavior.

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

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

Front-loaded with the core purpose and normalization model, with pricing/docs demoted to a bracketed footer. Dense but every clause earns its place; the severity-class digression is slightly heavy for a description but still 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 4 params, no output schema, no annotations, and low schema coverage, the description adequately covers sources, normalization, and severity but leaves the agent without record-shape or three-of-four parameter explanations. Adequate but with clear gaps for a tool whose structured metadata is thin.

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

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

Schema description coverage is only 25% (only q is documented), so the description must compensate and does not. It adds no meaning for limit, since, or category, and notably never explains the 'vehicle' enum value, which the three named sources (FDA/USDA/CPSC) do not obviously cover.

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

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

States a specific resource (product recalls) and scope (FDA, USDA, CPSC aggregated into one normalized schema), clearly indicating this is the cross-agency tool. It does not name or contrast the category-specific siblings (gov_recalls_food, gov_recalls_drug, etc.), so differentiation is implied rather than explicit.

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

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

Usage is only implied: covering all three agencies signals this is the general fallback vs the per-category siblings, and 'Newest first' gives ordering context. There is no explicit when-to-use/when-not guidance and no routing to the six category-specific recall tools, which is a notable gap.

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

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

With no annotations, the description carries the full burden and does well: it discloses the exact return fields, that no rows come back, the free price via x402, and the polling cadence. It stops short of stating rate limits or cursor expiry semantics, so a 4 rather than 5.

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

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

Front-loaded with the free/paid distinction and the return-shape summary; every sentence earns its place. The trailing bracketed HTTP/price/docs metadata is useful but slightly elongated.

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

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

No output schema exists, so the description compensates by enumerating the return fields, and it also clarifies the cost model and the relationship to the paid delta. An agent has everything needed to call this correctly.

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

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

Schema description coverage is 100% and the sole 'since' parameter is fully documented in the schema (opaque cursor from next_cursor, omit to bootstrap). The description adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource ('count of product recalls changed since your cursor') and explicitly scopes the output ('returns changed_count, next_cursor, and as_of only — no rows'), which cleanly separates it from the sibling gov_recalls_delta that returns actual rows.

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

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

Gives explicit when-to-use guidance ('Poll hourly for $0') and names the alternative plus the trigger for escalating to it ('call the paid delta only when changed_count > 0'). This is exactly the routing information an agent needs.

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

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

No annotations provided, so the description carries the burden. It discloses normalization across three agencies and severity classing, plus pricing ($0.01 via x402) and the HTTP endpoint, which is genuine behavioral context. It omits auth needs, rate limits, and result format/return shape despite no output schema.

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

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

The core sentence is efficient and front-loaded, but the description largely repeats itself ('Latest consumer product recalls' appears twice) and appends a bracketed metadata blob. Redundancy dilutes an otherwise compact statement.

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 list endpoint with no annotations and no output schema, the description covers source, shape, and category. However it leaves the two undocumented parameters and the return format unexplained, leaving gaps an agent would need to resolve.

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

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

Schema coverage is only 33%: only q has a description ('Match against product, brand, or hazard'). The description adds nothing about limit (required, 1-50) or since (date filter). With low coverage the description should compensate but doesn't.

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?

Specific verb+resource: 'Latest consumer product recalls' with named sources (FDA/USDA FSIS/CPSC), severity classing, and product details. Clearly distinguishes from the generic gov_recalls and category siblings (food, drug, device, vehicle) by declaring itself pre-filtered to the consumer category.

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?

States the tool is 'pre-filtered to the consumer category' and 'Same shape as /v1/recalls', which implies usage context versus the generic parent. However, it does not explicitly say when to choose this over gov_recalls_food or gov_recalls_drug, nor list 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?

No annotations, but the description handles the burden: discloses return shape (recalls plus changed_count and new next_cursor), cursor stability across restarts, bootstrap behavior, and cost/HTTP details ($0.005 via x402, GET endpoint). Does not spell out pagination limits but covers most behavioral traits.

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

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

Front-loaded with the core meaning and scoping, dense but each sentence adds a distinct fact. The bracketed HTTP metadata is slightly noisy but useful; no real waste.

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

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

For a single-param, no-output-schema delta endpoint, it covers purpose, bootstrap, cursor stability, return fields, sibling routing, and access/cost. Nothing an agent needs to call it correctly is missing.

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

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

Single parameter with 100% schema coverage (baseline 3), and the description adds value beyond schema: how to source the value (next_cursor from last call) and the bootstrap-once behavior when 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?

States the specific verb/resource ('product recalls changed since your cursor') and disambiguates from the full listing ('delta of /v1/recalls'). Distinguishes from siblings like gov_recalls and gov_recalls_changes clearly.

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

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

Gives explicit when and how: pass since=<next_cursor>, omit once to bootstrap, and recommends polling the free sibling gov_recalls_changes and paying only when there's something to fetch. That's a concrete routing rule to 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?

No annotations are provided, so the description carries the full disclosure burden. It does add useful context: a normalized multi-agency schema, severity classing, product details, and an HTTP endpoint with a $0.01 x402 payment requirement. However, it says nothing about pagination, rate limits, or response shape, leaving gaps for a tool with a payment gate.

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 definition front-loads the resource, but the opening is redundant, restating 'Latest medical device recalls' in two consecutive sentences. The trailing bracket with endpoint, price, and docs URL is useful metadata yet adds bulk. Roughly three of the sentences carry the description's substance.

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

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

There is no output schema and no annotations, so the description should shoulder more. It partially does, sketching the normalized severity/product output, but omits the input filters (limit, since) and any behavioral caveats. Adequate but with clear gaps for a 3-parameter paid tool.

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

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

Schema description coverage is only 33%: 'q' is documented but 'limit' and 'since' are not. The description mentions no parameters at all (its 'product details' phrase refers to output, not input), so it does not compensate for the uncovered parameters. An agent gets no guidance on the date filter or result cap from either source.

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 resource ('medical device recalls') and scope, adding that the results are normalized across FDA/USDA FSIS/CPSC and pre-filtered to the device category. This differentiates it from the generic gov_recalls and the other category siblings (drug, food, vehicle) without opening their schemas. It falls short of 5 only because it does not address the changes/delta siblings.

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

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

Usage is only implied through 'pre-filtered to the device category,' which tells the agent this is the device slice. There is no explicit when-to-use statement, no exclusion, and no routing to alternatives such as gov_recalls for all categories or gov_recalls_drug/food for other categories. The comparison is to a raw endpoint (/v1/recalls), not to a sibling tool.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses the HTTP GET verb (implying a read-only retrieval), the x402 price of $0.01, that output is a normalized schema with severity classing and product details, and that the shape matches /v1/recalls. It omits pagination/ordering behavior and any rate-limit or freshness caveats, so it is good but not complete.

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

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

Front-loaded with the key phrase, but the first sentence ('Latest drug and pharmaceutical recalls (FDA/USDA/CPSC normalized).') is near-verbatim repeated by the opening of the second sentence, which is wasted space. The trailing bracket metadata is functional but dense.

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

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

For a simple read-only list tool with no output schema, the description covers the return shape by reference ('Same shape as /v1/recalls') and the data sources. However it leaves the required 'limit' parameter and the 'since' filter unexplained and gives no pagination guidance, so an agent has gaps to fill.

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

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

Schema coverage is only 33% – only 'q' is documented in the schema, while 'limit' (required!) and 'since' are undocumented there. The description adds nothing about any parameter, not even referencing date filtering, so it fails to compensate for the coverage gap. 'Latest' hints at recency ordering but says nothing about the 'since' filter or 'limit'.

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

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

States a specific verb+resource (drug/pharmaceutical recalls) with scope (FDA/USDA FSIS/CPSC normalized, severity classing, product details) and notes it is 'pre-filtered to the drug category', which implicitly distinguishes it from sibling category variants like gov_recalls_food, gov_recalls_device, and gov_recalls_vehicle. It never names those siblings, so differentiation is left partly to inference.

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

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

'Same shape as /v1/recalls, pre-filtered to the drug category' implies this is the drug-scoped variant of gov_recalls, which is decent implicit routing. But there is no explicit when-to-use guidance and no mention of the alternatives (gov_recalls, gov_recalls_changes, gov_recalls_delta), so an agent must infer the relationship.

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

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

No annotations are provided, so the description carries the full burden. It discloses the HTTP method/endpoint (GET), the paid access model ($0.01 via x402), a docs link, and the return shape (normalized schema, severity classing, product details). Remaining gaps are pagination, ordering, and rate limits.

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

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

Front-loaded and readable, with the operational details (endpoint, price, docs) correctly bracketed at the end. However, the opening two clauses both restate 'latest food safety recalls,' which is redundant padding.

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

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

With no output schema and no annotations, the description does cover the payment/endpoint requirement and points to '/v1/recalls' for shape, plus severity and product detail fields. It remains silent on the two undocumented parameters and on pagination/ordering, leaving real gaps for a 3-parameter tool.

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

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

Schema description coverage is only 33% (only 'q' is documented), so the description must compensate for the undocumented 'limit' and 'since' parameters, and it does not. 'Latest' vaguely implies default recency ordering but says nothing about the date filter, result count, or the free-text query 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?

States a specific verb (retrieve latest) plus resource (food safety recalls) and scopes the source set (FDA/USDA FSIS/CPSC normalized). The phrase 'pre-filtered to the food category' implicitly distinguishes it from gov_recalls and the other category siblings (device, drug, vehicle, consumer), though none are named explicitly.

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

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

Usage is only implied: 'latest' signals recency-oriented retrieval and the food scope signals category selection, but there is no explicit when-to-use guidance versus gov_recalls, gov_recalls_changes, or the delta siblings, and no stated 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 no annotations, the description carries the full burden and does reasonably well: it discloses a normalized multi-agency schema, severity classing, product details, the HTTP endpoint, and a per-call price ($0.01 via x402). It omits pagination/response-size behavior and any auth notes, keeping it short of a 5.

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

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

The first sentence ('Latest vehicle recalls (FDA/USDA/CPSC normalized)') is essentially restated by the second ('Latest vehicle recalls across FDA, USDA FSIS, and CPSC...'), so a sentence does not fully earn its place. The endpoint/price/docs footer is compact and useful, and the key framing 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?

No output schema and no annotations, so the description must cover everything. It does explain data provenance and output shape at a high level, but leaves the limit/since semantics and a clear category-selection rationale unexplained for a 3-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 coverage is only 33% (only q is documented). The description adds no meaning for limit or since and never explains that limit caps results at 50 or that since filters by date. The 'same shape as /v1/recalls' pointer is a weak proxy for the undocumented parameters.

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

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

States a specific resource ('latest vehicle recalls') and the normalizing sources (FDA/USDA FSIS/CPSC). The clause 'pre-filtered to the vehicle category' implicitly distinguishes it from the base gov_recalls and the other category siblings (food, drug, device, consumer), though it never names them explicitly.

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

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

Usage is only implied: an agent infers 'use this when you specifically want vehicle-category recalls.' There is no explicit when-to-use statement, no when-not-to-use, and no pointing to sibling tools like gov_recalls (all categories) or gov_recalls_delta (changes).

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

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

With no annotations, the description carries the full behavioral burden and mostly does: it discloses cost (free via x402), the return shape (changed_count, next_cursor, as_of only — no rows), and the cursor-chaining behavior. It does not state explicit rate limits or confirm read-only semantics beyond the hourly-poll guidance, so it falls just short of full 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?

Front-loads the 'Free:' qualifier and the core behavior, then layers the routing rule and metadata. Sentences are dense but each earns its place; the bracketed HTTP/x402/docs tail is mildly noisy but useful reference info.

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

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

With no output schema and no annotations, the description does the heavy lifting by naming the three returned fields and clarifying that no rows come back, plus cost and polling cadence. Only auth/permission specifics and rate limits are unaddressed, which are minor for a free read probe.

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

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

Schema coverage is 50%: 'since' is fully documented in the schema as an opaque cursor from next_cursor, and the description only echoes the cursor concept ('changed since your cursor') without adding syntax. The enum-only 'category' param is self-evident but gets no explanation in either place, so the description does not materially compensate for the coverage gap.

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

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

States a specific verb+resource+scope: 'count of materially-moved markets in the segment changed since your cursor.' It explicitly contrasts with the paid sibling ('call the paid delta only when changed_count > 0'), so an agent can separate probability_board_changes from probability_board_delta without opening either schema.

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

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

Gives explicit operating instructions: 'Poll hourly for $0 and call the paid delta only when changed_count > 0.' This names both the cadence and the alternative (delta) plus the condition that selects it, leaving nothing to inference.

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

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

With no annotations, the description carries the full burden, and it does disclose access-relevant behavior: the HTTP endpoint, the $0.04 x402 payment/auth requirement, and the returned fields (blended live probabilities, resolution dates, slugs). It omits rate limits, staleness, and pagination behavior, but the auth/cost disclosure is meaningful context beyond the schema.

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

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

Front-loaded with the core purpose and return content, and the trailing HTTP/pricing/docs block is compact. It is mildly redundant ('in one call' followed by 'one-call board') but otherwise efficient.

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

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

With no output schema and no annotations, the description compensates by enumerating return fields, which is what an agent needs to know before calling. The one gap is the undocumented limit parameter; otherwise it is complete for a bulk-read 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?

There is one parameter (limit, required, 1-50) and schema description coverage is 0%, so the description must compensate but does not mention limit at all. 'Top markets by volume' loosely hints at ordering, but whether limit caps the returned count or selects a tier is left unspecified.

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

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

States a specific verb+resource: a board of climate and weather prediction markets with live probabilities. The domain ('climate and weather') separates it from the crypto/econ/sports board siblings. It stops short of naming the closest alternatives (probability_calendar_climate, probability_movers_climate) that an agent must choose between.

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 bulk read for agents tracking the state of climate and weather at a glance' plus 'per-market slugs for drill-down' implies the board-then-fetch workflow, so usage is inferable. However there is no explicit when-not guidance and no mention of how this differs from the calendar or movers variants in the same family.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the transport, cost, and payment mechanism (GET /v1/board/crypto, $0.04 via x402) plus a docs link, which is genuine value beyond structured fields. It stops short of disclosing pagination, freshness/latency, or whether limit truncation silently drops markets.

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

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

Front-loaded with the core purpose and return contents, and the cost/endpoint metadata is sensibly relegated to a trailing bracket. Slight redundancy across the first two sentences ('all active crypto markets' vs 'one-call board of the most active crypto markets') costs it a perfect score.

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

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

For a single-param list tool with no output schema, the description covers purpose, returned fields, drill-down affordance (per-market slugs), and access/cost details. Remaining gaps (pagination behavior, data freshness, explicit sibling routing) are minor for a tool of 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?

One parameter (limit) exists with 0% schema description coverage, and the description never mentions it or its range/default. 'Top markets by volume' hints that results are capped, but no meaning is added beyond the schema's min/max/default. Self-evident param keeps this 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 gives a specific verb+resource ('board of the most active crypto prediction markets') and enumerates the returned fields (blended live probabilities, resolution dates, per-market slugs). The 'crypto' domain clearly scopes it within the large probability_board_* family, but it never explicitly distinguishes itself from near-name siblings like probability_board_changes or probability_board_delta.

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 bulk read for agents tracking the state of crypto at a glance' implies the use case (broad situational snapshot rather than a targeted query). However, no when-not-to-use condition is given and no alternative sibling is named (e.g., changes/delta for diffs, probability_calendar_crypto for scheduled events), leaving routing to inference.

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

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

No annotations exist, so the description carries the full behavioral burden and discharges it: it discloses delta-only semantics, the returned fields, cursor stability across restarts, one-time bootstrap, and the $0.015 x402 cost. Pricing and cursor-lifecycle facts are exactly the context an agent cannot infer from the schema.

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

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

Front-loaded and informative, but redundant: "materially-moved markets in the segment changed since your cursor" is restated as "materially-moved markets... added or changed after it", and the trailing HTTP/pricing block duplicates the cost already stated in prose. The garbled opening token "(delt." further mars an otherwise clear 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?

No output schema and no annotations, yet the description still covers return fields, cursor lifecycle, bootstrap behavior, cost, and the free alternative. An agent has everything needed to call it correctly on both the first and subsequent invocations.

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

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

Schema coverage is 50% (since is documented inline, category is enum-only). The description compensates for since by explaining it is an opaque cursor sourced from next_cursor and that omitting it bootstraps at now. It adds real meaning beyond the schema, though category semantics remain undocumented.

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

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

States a specific verb+resource: a keyset delta over /v1/board/:category returning only materially-moved markets added or changed since a cursor. It also names the payload (changed_count, next_cursor) and the free sibling /changes, so it is clearly distinguishable from probability_board_changes and its per-category relatives.

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

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

Gives explicit when/when-not and an alternative: "Poll the free sibling /v1/board/:category/changes for counts and pay only when there is something to fetch", plus the bootstrap rule "Omit since once to bootstrap". An agent knows exactly when to call this paid tool versus the free one.

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

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

With no annotations, the description carries the full burden. It does disclose read semantics (GET /v1/board), the cost model ($0.04 via x402), and a docs URL, which are genuinely useful. It does not, however, say anything about rate limits, caching/freshness of the 'live' probabilities, or what happens when limit is applied.

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

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

Front-loaded with the core scope in the first sentence, followed by what the board contains. The bracketed HTTP/price/docs metadata is compact. Three sentences plus metadata, no filler.

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

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

For a simple bulk-read tool with one parameter, no output schema, and no annotations, the description adequately covers scope, content, and access mechanics. The only real gap is the undocumented limit parameter.

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

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

Schema description coverage is 0% and the single required 'limit' parameter is never mentioned in the description; only 'top markets by volume' hints at a bounded set. The parameter name, default (20) and max (50) make it largely self-explanatory in the schema, so this is an acceptable but not compensating level.

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

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

States a concrete verb and resource ('all active economics markets', 'one-call board of the most active economics prediction markets') and enumerates the return content (volume, blended live probabilities, resolution dates, slugs). It is clear what it does, but it does not explicitly distinguish itself from the adjacent siblings probability_board_delta, probability_board_changes, or probability_movers_economics.

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 bulk read for agents tracking the state of economics at a glance' implies when to reach for it (a snapshot overview), but there are no explicit when-not conditions and no alternatives are named. The delta/changes/movers siblings are the natural alternatives and go unmentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the return contents and the commercial/logistical context ($0.04 via x402, GET endpoint, docs URL), which is real value beyond structured fields. It does not, however, state whether reads are paginated, how 'top by volume' is scoped/capped, or refresh cadence.

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?

Purpose is front-loaded in the first sentence and the whole body is three sentences. There is mild redundancy ('in one call' / 'One-call board') and the bracketed HTTP/price/docs block is dense, but nothing is wasted.

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

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

For a simple bulk-read tool with no output schema or annotations, the description adequately covers what is returned (probabilities, resolution dates, slugs) plus cost and endpoint. The main gap is the undocumented limit/pagination behavior, which matters because the whole tool is a bounded board.

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

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

Schema description coverage is 0% and the sole parameter (limit) is never mentioned in the description. The schema's type, default, and min/max are self-describing, but the description adds no meaning about what limit controls (number of markets returned) or how it interacts with 'top markets by volume'.

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+resource (a bulk board of entertainment prediction markets) and enumerates the payload (blended live probabilities, resolution dates, per-market slugs). The 'entertainment' qualifier cleanly distinguishes it from the many probability_board_* category siblings. An agent can select it without opening the schema.

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

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

'The bulk read for agents tracking the state of entertainment at a glance' gives an implied usage context, and 'per-market slugs for drill-down' hints at the follow-up tool. However, no alternative is named (e.g., probability_board_delta, probability_calendar_entertainment, probability_movers_entertainment) and there are no explicit when-not conditions.

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

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

With no annotations, the description carries full burden; it discloses that this is a read/bulk operation and describes the returned fields and the x402 payment ($0.04). However it omits permissions/auth detail, rate limits, and staleness/latency behavior that an unannotated tool should surface.

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

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

Front-loaded with purpose first, then payload detail, then usage, followed by a compact technical footer with endpoint, price, and docs URL. Minor redundancy in repeating the 'one call' idea ('in one call' / 'One-call board'), but no wasted space.

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

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

No output schema exists, so the description appropriately specifies the return contents (metrics, dates, slugs for drill-down), and it conveys the read/bulk nature. The main gap is the undocumented limit parameter, which leaves invocation detail incomplete for a required argument.

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 'limit' parameter, which is required with a default of 20 and max of 50, is never mentioned in the description. With 0% schema description coverage, the description does not compensate by explaining count semantics, so the agent must infer that limit controls the number of top markets returned.

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

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

States a specific verb and resource (active Federal Reserve prediction markets with live probabilities) and details the payload (top markets by volume, blended probabilities, resolution dates, slugs). It is clearly distinct from the *_calendar_* and *_movers_* siblings by the 'board' scope, but never names a sibling to make the boundary explicit.

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

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

'The bulk read for agents tracking the state of Federal Reserve at a glance' gives a clear use case and distinguishes it as a bulk/snapshot read. It offers no exclusions and never names alternatives like probability_calendar_fed or probability_movers_fed, so the guidance stops at context rather than routing.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses the payload contents (top markets by volume, blended live probabilities, resolution dates, per-market slugs) and the transport/cost (HTTP GET, $0.04 via x402). It omits update cadence, pagination, and error behavior, keeping it short of a 5.

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

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

Front-loaded with the core purpose, then elaboration, then machine-readable metadata. Slightly redundant between 'All active US politics markets with live probabilities in one call' and 'One-call board of the most active US politics prediction markets,' but overall tight and well ordered.

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

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

With no output schema and no annotations, the description must describe the return, and it does list the key fields (volume, blended probabilities, resolution dates, slugs). Missing limit/pagination semantics and freshness details leave minor gaps for a one-parameter board 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 parameter (limit) has 0% schema description coverage and is never mentioned in the description. 'Top markets by volume' faintly implies an ordered top-N cut, but the default, min, and max are left entirely to the schema, so the description adds no meaning beyond structured data.

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

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

States a specific resource (active US politics prediction markets) and what it returns (live probabilities, resolution dates, slugs) in one call. The 'politics-us' scope is explicit enough to separate it from the sibling probability_board_politics-world without opening either schema.

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

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

Usage is implied via 'the bulk read for agents tracking the state of US politics at a glance' and the mention of 'per-market slugs for drill-down,' which hints at a follow-up tool. However, no alternative is named and no when-not condition is given (e.g., use probability_board_delta for changes, probability_get for a single market).

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: top markets by volume, blended live probabilities, resolution dates, per-market slugs, plus the HTTP endpoint and $0.04 x402 price. It stops short of explaining auth/payment flow or rate limits/pagination, which a paid endpoint would benefit from.

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

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

Front-loads the purpose in the first sentence and layers detail predictably, ending with an operational HTTP/pricing/docs footer. There is mild redundancy between the first and second sentences ('one call' / 'one-call board'), but overall it is tight.

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 or annotations, the description usefully enumerates what comes back (markets, probabilities, resolution dates, slugs) and gives cost/endpoint/docs. It is nearly complete for a bulk-read tool, lacking only limit/pagination guidance and any note on refresh cadence of 'live' probabilities.

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 required parameter (limit) has 0% schema description coverage and the description never mentions it, so it adds no semantic meaning about how many markets are returned or how limit interacts with the volume-based ranking. The schema provides constraints but no semantics, and the description does not 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?

States a specific verb and resource ('all active world politics markets with live probabilities in one call') and distinguishes by scope from closely named siblings like probability_board_politics-us. It does not explicitly name alternatives, but the 'board'/snapshot framing differentiates it from calendar and movers siblings.

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

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

'The bulk read for agents tracking the state of world politics at a glance' implies the intended use case. However, there is no explicit when-to-use vs. when-not guidance, no mention of alternatives for drill-down or delta tracking, and no prerequisites stated.

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

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

No annotations are provided, so the description carries the full burden. It indicates this is a read-only bulk operation returning blended live probabilities, resolution dates, and slugs, which is useful. However, it doesn't disclose rate limits, pagination behavior, freshness of live probabilities, or how limits beyond the top 20 are handled.

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, and avoids unnecessary repetition. Slight redundancy in the first two sentences ('All active...markets' vs 'most active...markets') could be tightened, but overall it's efficient.

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

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

For a tool with no output schema and 0% schema coverage, the description should do more to explain the 'limit' parameter and return format (e.g., what fields are included, whether probabilities are percentages or decimals). It mentions some return contents but lacks detail on the parameter behavior and output structure, leaving gaps 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 1 required parameter and 0% schema description coverage, the description fails to explain the 'limit' parameter at all. It mentions 'top markets by volume' but doesn't specify that the limit applies to the number of markets returned or what the default/max values are. This is a significant omission for an agent needing to know how to control the output size.

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

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

The description states a specific verb ('All active...markets'), resource ('science and technology prediction markets'), and scope ('top markets by volume'). It clearly distinguishes itself from sibling boards like probability_board_politics-us or probability_board_crypto through the science-tech domain and from probability_calendar_science-tech by describing a live probability board rather than a calendar view.

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 clear context: 'for agents tracking the state of science and technology at a glance' and 'bulk read,' which implies when to use it versus drill-down tools. However, it doesn't explicitly name alternatives or state when NOT to use this tool (e.g., for individual market lookups or historical data).

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

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

With no annotations, the description carries the full burden. It discloses useful behavior about the returned data (top markets by volume, blended live probabilities, resolution dates, slugs) but says nothing about auth needs, rate limits, or how the limit is applied. It is transparent about content but thin on operational behavior.

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