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

No annotations are provided, so the description carries the full burden, yet it discloses no behavioral traits beyond the basic operation. It says nothing about duplicate-feed handling, URL validation, required permissions, or error behavior for an invalid feed URL.

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 efficient sentence with the core action front-loaded and zero filler. Every clause ('by URL', 'optionally assign to a category') carries 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?

An output schema exists, so return values need not be explained, and the schema fully documents the parameters. Still, as a mutation tool with no annotations, it omits duplicate handling and failure modes, leaving gaps an agent might need.

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 both parameters (url and category) are already fully documented in the schema, including the auto-create behavior for categories. The description adds no syntax or format detail beyond what the schema provides, making the baseline 3 correct.

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

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

The description uses a clear verb ('Add') plus a specific resource ('RSS/Atom feed') and the mechanism ('by URL'), which is unambiguous on its own. However, it does not distinguish this from the sibling import_opml_tool, which also adds feeds in bulk, leaving the agent to infer the boundary.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no mention of alternatives such as import_opml_tool for bulk additions. The only contextual hint is the word 'optionally' for the category, which does not route the agent between tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'Create' but discloses nothing about duplicate-name handling, required permissions, idempotency, or whether the call is reversible — real gaps for a mutation tool. An output schema exists, so return values need not be explained here.

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 waste. It is efficient, though it sits close to the under-specification line rather than being genuinely 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?

For a one-parameter creation tool with an output schema, the basics are covered and return values need not be described. Still, as a mutation with zero annotation coverage, it omits duplicate handling, error behavior, and permissions, so 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 100% and there is a single parameter, so the schema fully documents 'name'. The description adds no syntax, format, or uniqueness constraints beyond what the schema already states, which lands at the baseline 3.

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

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

The description gives a specific verb (Create) and resource (a new category), which is unambiguous about what the tool does. It does not, however, differentiate from adjacent siblings such as rename_category_tool or delete_category_tool, leaving the routing distinction to the tool names alone.

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, nor any mention of the alternative category tools. An agent must infer from the name that this is the creation path versus list/rename/delete.

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 does usefully disclose the cascade effect ('feeds in this category become uncategorized'), which the schema does not. However, it omits whether the deletion is permanent/irreversible, whether confirmation or elevated permissions are required, and whether the feeds themselves are affected beyond losing their category.

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

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

Two short sentences, no filler, and the core action is front-loaded with the side effect immediately after. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained. For a destructive mutation with zero annotations, however, the definition should at least state permanence and any required permissions or confirmation; the cascade note partially compensates but leaves real 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?

Single parameter with 100% schema description coverage ('Category ID to delete'), so the schema already documents it fully. The description adds no format or sourcing detail beyond what the schema provides, which is the expected baseline 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 and resource ('Delete a category'), which clearly separates it from delete_feed_tool and the other category siblings by resource name. It does not explicitly name an alternative tool or scope, but the purpose 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as rename_category_tool or list_categories_tool. The only usage-relevant signal is the implied consequence that feeds are detached, which the agent must infer as the reason to be careful.

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 destructive cascade ('and all its entries'), which goes beyond the schema, but it omits irreversibility, permission requirements, and confirmation semantics for a permanently destructive operation.

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 and its main side effect front-loaded. No filler or redundancy.

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

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

An output schema exists, so return values need not be explained, and one parameter at full coverage is documented. However, for a destructive tool with no annotations, the description leaves the agent without warnings on irreversibility or required permissions.

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

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

Schema description coverage is 100% with a single required feed_id already documented as 'Feed ID to delete'. The description adds no format, valid-range, or lookup guidance beyond what the schema provides, 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 (Remove) and resource (a feed), plus the cascading scope (all its entries). Clear enough to distinguish from list_feeds_tool or add_feed_tool, though it does not explicitly name the sibling it contrasts with.

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 alternatives (e.g., delete_category_tool, or archiving a feed), no prerequisites, and no warning about when it should not be called. Usage is only implied by 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, the description carries the full burden. It does disclose the return format (OPML XML string) and that all feeds are included, which implies a safe read. However, it never explicitly states the operation is non-destructive/read-only or notes any size/rate constraints for large feed sets.

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 filler. Every word contributes information about scope and output format.

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 is present, so return-value details need not be re-explained, and a zero-parameter tool has little else to document. The only minor gap is the absence of read-only/behavioral confirmation, which annotations 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?

The tool takes zero parameters, so the baseline of 4 applies. Nothing in the schema needs compensating for, and the description correctly implies no filtering options 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 (export), resource (all feeds), and output format (OPML XML string) in one clause. This clearly distinguishes it from the inverse sibling import_opml_tool without needing to name it.

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 purpose implies when to use it (backing up/migrating feeds), but there is no explicit when/when-not guidance and no mention of import_opml_tool as the counterpart operation. Usage is inferable from the name and description but not 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?

No annotations are provided, so the description carries the full burden. It implies a read operation via 'Get details,' but does not state read-only safety, idempotency, permissions, error behavior when a feed ID is missing, or any other behavioral trait.

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

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

The description is a single, front-loaded sentence that clearly states the core operation and mentions entry counts. It is efficient and appropriately sized, though not maximally structured for an agent routing decision.

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

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

The tool is simple, the input schema is fully described, and an output schema exists, so return values need not be explained. However, the description lacks usage context and behavioral details that would help an agent confidently select it over alternatives.

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 feed_id parameter is fully documented in the schema. The description adds no further meaning beyond what the schema already provides, making the baseline score appropriate.

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

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

The description states a specific verb (Get) and resource (a single feed) and scopes it to one feed, which distinguishes it from list_feeds_tool. It does not explicitly name or contrast with siblings, so it falls short of the top score.

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 guidance, no prerequisites, and no mention of alternatives such as list_feeds_tool for multiple feeds. Usage is only implied by the wording 'a single feed'.

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 behavioral burden. 'Get' implies a non-mutating read, and the output schema documents the return shape, but the description does not explicitly confirm it is side-effect free or note any caching/refresh semantics.

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 compact sentence that front-loads the verb and lists the key outputs with no filler. Nothing wasteful, though it could be marginally tighter.

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, return values need not be explained, and the zero-parameter signature needs no elaboration. The description is complete enough for an agent to call it correctly; only explicit read-only confirmation 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 there is nothing to document; baseline for an empty schema is 4. 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?

States a specific verb ('Get') and resource ('dashboard stats') and enumerates the returned metrics: total feeds, unread count, entries per category. It is unambiguous and clearly distinct from the CRUD-oriented siblings, though it does not name 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 implied by the name and the 'dashboard stats' framing, but there is no explicit when-to-use or alternative-selection guidance. For a zero-parameter overview tool the intent is fairly obvious, so this is adequate rather than strong.

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 a valuable non-obvious side effect — categories are auto-created from outline groups — which goes beyond the tool name. However, it omits duplicate handling, whether existing feeds are merged or skipped, and any permission/auth requirements for a mutation operation.

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 compact sentence with the verb and resource front-loaded and no filler. It is appropriately sized, though the category-creation side effect could have been surfaced more prominently given it is the most consequential behavior.

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 needn't be described, and the schema covers the sole parameter. But for a bulk mutation tool with no annotations, the description should address idempotency and what happens to pre-existing feeds/categories — a real gap for an import operation.

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 with 100% schema description coverage, so the schema already defines file_path. The description adds no format, path-resolution, or encoding detail beyond what the schema provides, 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 ('Import') and resource ('feeds from an OPML file') plus a secondary effect ('creating categories from outline groups'). It clearly distinguishes itself from the sibling export_opml_tool by direction, though it never names the sibling 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?

No guidance on when to use this versus add_feed_tool or export_opml_tool, no prerequisites (e.g., file must be accessible/readable), and no exclusions. The agent must infer usage 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, the description carries the burden, but for a trivial read-only enumeration there is little to disclose. It does convey that results are enriched with per-category feed counts, which is useful output-shaping info, though it never states read-only semantics, auth needs, or ordering/pagination.

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 the verb, resource, and the one differentiating detail. No filler, nothing redundant.

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 needn't be explained, and with no inputs there are no parameters to document. For a zero-arg listing tool this is close to sufficient, with only the absence of read-only/ordering context as a minor gap.

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

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

The tool takes zero parameters, so per the baseline the description has nothing to compensate for. The phrase 'with feed counts' describes the shape of the result rather than any input, which is harmless but not required.

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 ('List all categories') and adds a distinguishing detail ('with feed counts') that separates it from list_feeds_tool and get_stats_tool. It doesn't explicitly name sibling boundaries, but the combined categories+feed-count scope 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?

No when-to-use guidance, no prerequisites, and no routing to alternatives. Usage is only implied by the name 'list_categories_tool' itself; the description adds nothing about when this is preferable to, say, list_feeds_tool or get_stats_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?

No annotations are provided, so the description carries the full burden. It does disclose one non-obvious behavioral trait: date filters compare against COALESCE(published, created_at), so undated entries are matched by ingest time. That is real value beyond the schema, but read-only safety, ordering, and paging behavior are left unstated.

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 short sentences, front-loaded with the core action and then the non-obvious filter semantics. The opening sentence is slightly generic and restates the name, but nothing is padded or duplicated.

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 and 100% schema description coverage, most of the burden is already lifted. The description closes the main remaining gap (date-window column semantics) but omits ordering, whether unread_only is the significant default it appears to be, and routing versus search_entries_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 100%, so the baseline is 3. The description goes beyond it by explaining what column published_after/published_before/since_days actually compare against and what happens when published is null — context the schema itself never supplies.

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 ('List entries') with the qualifier 'optional filters', which is immediately distinguishable from mutation siblings like mark_read_tool or delete_feed_tool. It does not, however, differentiate itself from search_entries_tool, which is the nearest ambiguous alternative.

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?

Offers guidance on when to use the date-window filters ('to fetch only a trailing period instead of paging through everything'), which is a genuine usage hint. But it never says when to use this tool instead of search_entries_tool, nor when to prefer since_days over published_after/published_before beyond the mutual-exclusion note buried in the schema.

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 reveals only that unread counts are included and implicitly that it is a read; it says nothing about ordering, pagination, volume limits, or whether the category filter changes the shape of results.

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 zero waste. It is efficient, though the sparseness arguably under-serves a tool with an available filter parameter.

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 needn't be explained, and the tool has only one optional parameter. Still, for a discovery-style list tool with no annotations, the description omits any filtering or usage context the agent would need to route correctly among 17 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?

Schema description coverage is 100% ('Filter by category ID (optional)'), so the schema already documents the sole parameter. The description adds no filtering semantics or format detail beyond that, 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?

Clear verb+resource ('List all feeds') plus the notable payload detail of unread counts. It does not, however, distinguish itself from siblings like get_feed_tool or list_entries_tool, leaving the agent to infer the difference from names.

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 whatsoever: no mention of when to prefer this over get_feed_tool (single feed) or list_entries_tool (entries). The agent must infer usage from the tool name 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 are provided, so the description carries the full behavioral burden, and it discloses almost nothing: not that this is a state mutation, not whether it is reversible, not whether it affects unread counters, and not that omitting all three optional parameters is a no-op. The only hint of caution ("use with caution") lives in the schema, not the description.

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

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

One short sentence is front-loaded and free of filler, which is good. But the terseness crosses into under-specification rather than efficient conciseness for a mutation tool with three mutually exclusive scope options.

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 no-annotation mutation tool with three optional, scope-defining parameters the description should at minimum say that exactly one scope should be supplied and that state is changed. None of that is present.

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

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

Schema description coverage is 100%, so each of the three parameters is already documented in the schema (feed_id = all entries in a feed, entry_id = a single entry, all_entries = everything). The description adds no meaning beyond that, 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?

The description gives a clear verb+resource ("Mark entries as read") that an agent can act on immediately. It does not, however, distinguish this from the sibling mark_unread_tool or clarify whether the scope is a single entry, a feed, or everything — that distinction is only visible in 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?

There is no when-to-use guidance, no prerequisites, and no mention of the obviously related alternative mark_unread_tool. The agent gets no signal about when this tool is the right choice versus read_entry_tool or list_entries_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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is idempotent, whether it affects unread counters or feed state downstream, or whether re-marking an already-unread entry errors — all relevant for a mutation 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?

A single short sentence with zero filler, and the operation is front-loaded. It is under-specified rather than wasteful; the brevity is appropriate but extremely sparse.

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 single parameter is fully described in the schema. What is missing is any behavioral context for a state-mutating tool with no annotations — enough to be minimally viable, 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% for the single entry_id parameter, so the schema already documents it (type, minimum). The description adds no format, range, or sourcing detail beyond the schema, making 3 the correct 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?

States a specific verb ('Mark') and resource ('an entry') with the target state ('unread'), which clearly distinguishes it from the sibling mark_read_tool. However, it never names or contrasts with that inverse sibling, so an agent gets no explicit routing help beyond the tool name itself.

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 mark_read_tool or read_entry_tool, and no mention of preconditions such as the entry needing to exist. The agent must infer the use case 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, the description carries the full behavioral burden, and it discloses the single most important non-obvious trait: reading auto-marks the entry as read, a mutation side effect overlapping with mark_read_tool. It omits auth requirements, error behavior for missing/invalid IDs, and whether the mark is reversible.

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 waste, front-loading the primary action and appending the side effect in a parenthetical. Nothing is padded or restated.

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 the description covers the key side effect. For a one-parameter read tool the coverage is nearly sufficient, with only error/permission behavior left unstated.

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 coverage is 100%, so the baseline is 3. The schema documents entry_id as an integer with a minimum of 1, and the description adds nothing further about ID format or where to obtain 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?

States a specific verb and resource ('Get full content of an entry'), which implicitly distinguishes it from list_entries_tool and search_entries_tool by its single-entry full-content scope. It does not explicitly name siblings, so an agent must infer the boundary from the sibling list.

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 parenthetical hints at a side effect but gives no explicit when-to-use guidance versus list_entries_tool or search_entries_tool, nor when-not to call it if the agent only wants to preview an entry. Usage is implied rather than 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 discloses the key behavioral traits: network activity ('over the network') and a latency warning ('Slow — takes 30-60s for all feeds'). It doesn't mention whether it blocks, is idempotent, or what errors occur on failure, but the performance profile is well surfaced for a no-annotation 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?

Three short sentences, front-loaded with the action and immediately followed by the latency caveat and routing guidance. Every sentence earns its place with no 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?

An output schema exists so return values need not be explained. For a single-param, no-annotation tool with a clear latency profile and explicit sibling routing, the description is nearly complete; minor gaps include failure behavior and whether it deduplicates against existing entries.

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 parameter's meaning (optional feed_id, refreshes all if omitted) is already fully documented in the schema. The description adds no syntax or edge-case detail beyond the schema baseline, making 3 the appropriate score.

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: 'Crawl feed sources over the network for new content.' Clearly distinguishes from siblings like list_entries (reading cached content) and add_feed_tool (adding a source). An agent knows exactly what this does.

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 tells when to prefer alternatives: 'Prefer the systemd timer for background updates' and 'Use list_entries to read cached content.' Names both the preferred mechanism and a specific sibling tool for the read path, which is strong routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Rename' implies a mutation, but the description says nothing about required permissions, whether renaming is reversible, how name collisions are handled, or any side effects on feeds assigned to the category.

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 single short sentence is front-loaded and free of waste, but its brevity reflects under-specification rather than disciplined conciseness. There is no structural content beyond a four-word restatement of the title.

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

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

An output schema exists, so return values need not be explained, and both parameters are schema-documented. However, for a mutation tool with zero annotations, the description leaves the entire behavioral profile (permissions, reversibility, collision behavior) undisclosed, which is a substantial 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 100%, with both category_id and name documented in the schema, so the baseline is 3. The description adds no meaning beyond the schema (it does not clarify name constraints or the ID's origin), but it is not required to.

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 ('Rename a category'), which is minimally informative, but it essentially restates the tool title and name verbatim. It does nothing to distinguish this tool from siblings like create_category_tool, delete_category_tool, or list_categories_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?

No guidance is given on when to use this tool versus the sibling category tools, nor any prerequisites. The agent must infer usage entirely from the name and the surrounding tool 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 are provided, so the description carries the full behavioral burden. It says nothing about whether this is a read-only operation, how results are ranked or ordered, whether search is scoped to a feed or category, or how the limit interacts with result quality. For a no-annotation tool this is a substantial 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?

A single short, front-loaded sentence with no filler or redundancy. It is efficient, though the terseness is also what leaves the behavioral gaps unaddressed.

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 and full schema coverage, the description does not need to explain return values, which keeps it near adequate. However, it omits scope and read-only/safety context for a tool with no annotations, leaving an agent to infer too much.

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% — the schema already documents the limit range/default and FTS5 syntax support. The description's mention of 'titles and content' adds minor meaning by naming the searchable fields, but nothing about syntax or result semantics beyond the schema.

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

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

The description states a specific verb+resource combination ('Full-text search across entry titles and content') and even names the searched fields, which distinguishes it reasonably well from list_entries_tool. It does not, however, explicitly contrast itself with that sibling, 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?

There is no when-to-use guidance, no mention of the alternative list_entries_tool, and no statement of scope (all feeds? one feed? one category?). The agent gets no help deciding between searching and listing.

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