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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, fully covering the safety profile. The description adds nothing behavioral beyond naming the upstream API endpoint (tag/list); it gives no pagination, ordering, or scoping 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?

A single short sentence with the verb and resource front-loaded and zero filler. Appropriately sized for a parameterless listing 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?

With no parameters and an existing output schema, the description needn't explain return values, and it correctly identifies the resource. Its only shortfall is not distinguishing this listing tool from the other list-style siblings.

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

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

The tool takes zero parameters, so the baseline of 4 applies. There are no parameter semantics the description could add or omit.

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 ("List") and resource ("categories / tags"), making the tool's purpose immediately clear. It does not differentiate itself from siblings like freshrss_subscription_list or freshrss_label, so it falls short of a 5.

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

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

The description contains no when-to-use guidance, no prerequisites, and no reference to alternative tools for related listing needs. The agent must infer the usage context entirely 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?

With no annotations at all, the description carries the full burden and does disclose key traits: it is a write that creates :Document nodes, it pushes items through the 'fast engine client', and it is best-effort, returning {"ingested": None} rather than erroring when no engine is reachable — a genuinely useful failure-mode disclosure. It still omits permission/auth requirements and idempotency behavior on re-ingestion.

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 and efficient in three sentences. The trailing 'CONCEPT:AU-KG.ingest.enterprise-source-extractor' is internal jargon that adds no selection or invocation value and dilutes an otherwise tight 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?

An output schema exists, so return shape need not be explained, and the description still usefully pins down the no-engine case. For a single-parameter best-effort ingest tool it is nearly complete; the missing pieces are what permissions the write requires and what happens to duplicate items.

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

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

Only one parameter exists and schema description coverage is 100%, so the schema already documents params_json and its stream_contents keys. The description adds context (stream is fetched via the GReader API) but no parameter-level meaning beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource: ingesting FreshRSS feed items into epistemic-graph as :Document nodes, via the GReader API and fast engine client. It is clearly distinct from read-oriented siblings like freshrss_stream_contents, though it never explicitly names the alternative it is not (e.g. freshrss_ingest_subscriptions), so it stops short of full sibling 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?

Implied usage is reasonably clear: this is the tool that moves stream items into the knowledge graph, whereas freshrss_stream_contents merely reads them. However, there is no explicit when-to-use or when-not statement, no prerequisites (does the stream need to exist first?), and no named alternative, so an agent must infer the 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 it does usefully disclose best-effort semantics and the exact degenerate return shape ({"ingested": None}) when no engine is reachable. However, for a graph-mutating tool it says nothing about idempotency, duplicate handling, overwrite vs append behavior, or required auth/engine state, leaving significant gaps.

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

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

The core behavior and the best-effort caveat are front-loaded in three tight sentences with no filler. The trailing concept tag 'CONCEPT:AU-KG.ingest.enterprise-source-extractor' reads as internal jargon that adds little for an invoking agent, which slightly dilutes an otherwise efficient 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?

An output schema exists so return-value documentation is not required, and the description does explain the one unusual return case. Still, for an unannotated ingest/mutation tool it omits behaviors an agent needs (idempotency, re-run effects, prerequisites), so it is adequate but not complete.

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

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

Schema description coverage is 100% and the single param is documented in the schema as a reserved, currently empty JSON options string, so the description adds nothing but loses nothing by omitting it. Baseline 3 applies when the schema fully documents the 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 verb ('ingest') and resource ('FreshRSS subscriptions'), and details the target graph structure (:FeedSubscription nodes, :FeedCategory folders, :inCategory links). The plural resource noun makes it distinguishable from the sibling freshrss_ingest_items, though that distinction is left implicit rather than called out.

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 purpose statement (ingest subscriptions into the graph), but there is no explicit when-to-use or when-not-to-use guidance, and no mention of the alternative freshrss_ingest_items or freshrss_subscription_list. The agent must infer which ingest tool applies from the resource noun 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?

Annotations state readOnlyHint=false, openWorldHint=true, idempotentHint=false and destructiveHint=false, so the safety profile is already covered. The description usefully signals that 'full' contents (as opposed to stream summaries) are returned, but adds nothing on whether fetching has side effects (consistent with the non-read-only hint) or on output format. There is tension between the word 'Fetch' and readOnlyHint=false, but this mirrors GReader's POST-based item-contents endpoint rather than a clear claim of mutation, so it is not treated as a hard contradiction.

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

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

One short sentence with the operation front-loaded and no filler; the GReader parenthetical is the only extra detail and it is immediately 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?

An output schema exists, so return values need no explanation, and one param with no nesting keeps the surface small. Missing is the upstream step for obtaining item ids and any note on cost/batching when passing many ids.

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 0% schema description coverage, so the description must carry the load. It clarifies that the values are item ids and correspond to GReader 'i' parameters, but not accepted form (single string vs array), nor where the ids come from (e.g., freshrss_stream_contents).

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 ('Fetch full contents') scoped to 'specific item ids', which implicitly separates it from freshrss_stream_contents (whole-stream listing). It never names a sibling directly, so the differentiation is inferable 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?

There is no when-to-use or when-not-to-use guidance and no named alternative. The agent must guess that this is the follow-up call after stream_contents when full text is needed rather than summaries.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the safety profile is covered. The description adds the 'existing feed subscription' precondition, but says nothing about whether re-adding the same label duplicates it, errors, or is a no-op — a real gap given the non-idempotent hint.

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

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

A single sentence with no filler, front-loaded with the action. It is efficient, though arguably too terse for a mutation tool with undocumented parameters.

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

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

An output schema exists so return values need not be explained, but with 0% parameter coverage, no usage guidance, and no behavioral detail beyond the annotations, the definition leaves an agent guessing about preconditions and duplicate-label 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 0% with two required parameters, so the description must carry the burden. It loosely maps 'category' and 'feed subscription' to the parameters but gives no format guidance for feed_url (URL? feed ID?) and no clarification on whether the category value must match an existing category name.

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: adding a category label to an existing feed subscription. It is reasonably distinguishable from freshrss_subscribe (creates subscriptions) and freshrss_categories (manages categories), though the phrase 'category label' leaves some ambiguity about whether the category is created or must already exist.

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

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

No guidance on when to use this versus freshrss_categories or freshrss_subscribe, and no prerequisites stated (e.g., whether the category must already exist, or whether the feed must already be subscribed). The word 'existing' hints at a precondition but never spells it 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered by structured data. The description adds nothing beyond them — it does not say whether the change is reversible, whether it is persisted server-side, or what happens for invalid IDs.

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

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

One short, front-loaded sentence with no filler or redundancy. It is efficient, though its brevity borders on under-specification rather than true concision.

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

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

An output schema exists so return values need not be explained, and the operation itself is simple (one required ID parameter). Still, for a state-mutating tool the description omits any note on persistence, failure handling, or interaction with unread counts, leaving it only minimally adequate.

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

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

Schema description coverage is 0%, and the single parameter accepts either a bare string or an array of strings. The phrase "one or more items" is the only signal that both forms are accepted (multiplicity), which partially compensates for the undocumented anyOf shape, but it gives no format for the IDs.

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 and resource ("Mark ... items as read"), so the agent knows exactly what state change occurs. It does not, however, distinguish this from siblings such as freshrss_star or freshrss_label, which are also per-item state mutations, leaving sibling selection 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 statement of when to use this tool versus alternatives (freshrss_star, freshrss_label, freshrss_unread_count) and no prerequisites or exclusions. "One or more items" hints at batching but is not framed as usage guidance.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), so the bar is lower, but the description adds nothing on top: it doesn't say the state persists, what permissions are needed, or what happens when item_id doesn't exist.

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

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

A single short sentence with no filler and the operation front-loaded. It is efficient, though the brevity comes at the cost of the detail noted elsewhere.

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

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

An output schema exists so return values need not be explained, but for a 2-parameter mutation tool with zero schema coverage the description leaves the parameter meaning and usage context entirely undocumented.

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% for both parameters, so the description must carry the load. 'Star or unstar' vaguely maps to the starred boolean, but it never explains that starred=true stars and false unstars, that it defaults to true, or what format item_id takes.

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 pair (star/unstar) and resource (item), so an agent knows exactly what operation it performs. It does not, however, distinguish itself from similar siblings such as freshrss_label or freshrss_mark_read, which also mutate item state.

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

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

There is no statement of when to use this versus freshrss_label or freshrss_mark_read, nor any prerequisite or context. 'Star or unstar' only hints that the operation is a toggle; the caller must infer the rest.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuine context beyond that: continuation resumes a previous page (pagination semantics), newer_than is a unix-seconds watermark mapped to the GReader ot parameter, and the raw return payload shape is spelled out.

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 purpose is front-loaded in one short sentence, followed by compact per-parameter notes and a final statement of the return shape. Every sentence carries information an agent needs; there is no filler or repetition.

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

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

With an output schema present, the description need not enumerate return fields, yet it still notes the {"items": [...], "continuation": "..."} shape, and it covers pagination, ordering, and id construction. The only meaningful omission is the count parameter's semantics and default, which leaves a small hole in an otherwise complete definition.

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 carries the burden and largely does: it documents stream_id formats, the meaning of order ('o' vs 'n'), the newer_than-to-ot mapping, and the role of continuation. It omits the count parameter entirely, which is the one remaining gap in a five-parameter 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 first sentence states a specific verb and resource: 'Fetch items for a stream.' That is clear and unambiguous, and the subsequent detail about stream ids confirms the resource type. It does not, however, differentiate itself from siblings such as freshrss_item_contents or freshrss_unread_count, which an agent might otherwise confuse with a general item-fetch.

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: it is a read tool for listing stream items, and the description explains the id shapes needed to target a stream. There is no explicit when-to-use guidance, no mention of when to prefer freshrss_item_contents (full body) or freshrss_unread_count (counts only), and no stated 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?

Annotations already declare the key traits (write, non-idempotent, open-world, non-destructive), and the description adds no behavioral context beyond them. It does not mention duplicate handling, authentication, or rate limits, though the annotations cover the safety profile.

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

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

A single, front-loaded sentence with no wasted words; every part (feed, optional title/category) 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 simple 3-parameter write tool with output schema and annotations, the description covers purpose and optional fields, but it omits required-parameter emphasis and duplicate-subscription behavior. It is minimally adequate but leaves clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate, but it only names title and category as optional and never mentions feed_url or parameter formats. This adds marginal meaning beyond the schema.

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

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

States a specific verb 'Subscribe' and resource 'feed,' and the optional title/category scope is clear. The action is inherently distinct from sibling unsubscribe, so an agent can route correctly.

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

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

Provides no explicit when/when-not guidance or alternatives (e.g., freshrss_ingest_subscriptions). Usage is only implied by the tool name, which is insufficient for distinguishing ingestion vs manual subscription.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds nothing beyond that - no note on scope, pagination, or whether it returns all accounts' feeds - so it contributes no new 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?

A single short, front-loaded sentence with no filler or redundancy. It is tight and readable, though its very brevity is what leaves the other dimensions thin.

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-argument, read-only list tool with a full annotation set and an output schema that documents the return shape, the definition is essentially adequate. Only a brief note on scope (all subscriptions across categories/accounts) would round it out.

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, which is the baseline-4 case per the rubric, and the empty object schema with additionalProperties:false is unambiguous. There is nothing for the description to clarify about 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 ('List') and resource ('feed subscriptions'), so an agent immediately knows what the tool returns. It does not, however, differentiate itself from adjacent siblings such as freshrss_stream_contents or freshrss_ingest_subscriptions, which also deal with subscriptions/feeds.

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 offers no when-to-use context, no prerequisites, and no mention of alternatives even though several siblings (freshrss_ingest_subscriptions, freshrss_subscribe, freshrss_unsubscribe) operate on the same subscription domain. Usage is left entirely 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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds the per-stream granularity, which is meaningful context beyond the annotations, but says nothing about freshness, caching, or whether counts are affected by read state changes.

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

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

A single short sentence, front-loaded with the verb and result. It is efficient with no wasted words, though it borders on under-specification rather than fully optimized brevity.

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

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

An output schema exists, so return value details need not be explained, and the description correctly scopes the result to per-stream counts. It is adequate for a simple 0-param read tool, though it omits any note about which streams are included or authentication expectations.

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 are no parameter semantics to document; the baseline for a 0-param tool is 4. Nothing in the description is needed or missing here.

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

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

States a specific verb (Return) and resource (unread counts) with a scope qualifier (per stream). It is clearly distinguishable from sibling tools like freshrss_stream_contents (returns items, not counts) and freshrss_subscription_list, though it does not explicitly name those alternatives.

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

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

There is no guidance on when to call this versus the many other read-oriented siblings (stream_contents, categories, subscription_list). No exclusions, prerequisites, or context is implied beyond 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is partly covered. However, the description adds nothing: it does not say whether the feed's items are removed, whether calling twice errors (relevant given idempotentHint=false), or whether authentication is required for this mutation.

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

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

A single short sentence with zero filler and the action front-loaded. It is appropriately sized, though the brevity reflects under-specification rather than disciplined economy.

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

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

An output schema exists, so return values need not be explained. But for a mutation tool with an undocumented required parameter and no annotations covering consequences, the description omits what an agent needs: what state changes on success and what error conditions 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?

Schema description coverage is 0% and the single required feed_url parameter is typed only as a string. The description's phrase 'from a feed' implies feed_url identifies the target but gives no format guidance (URL vs. feed ID, case sensitivity), so it fails to compensate for the undocumented parameter.

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

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

The description states a specific verb (unsubscribe) and resource (a feed), clearly distinguishing it from the sibling freshrss_subscribe. It stops short of naming alternatives or scope, but the action is unambiguous.

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

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

There is no guidance on when to use this versus alternatives, no prerequisites, and no mention of what happens if the feed is not subscribed. The agent must infer all usage context from the name alone.

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