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?

readOnlyHint=true already tells the agent this is a safe, non-mutating read. The description adds that the scope is ALL feeds (no filtering) and the serialization format is OPML XML, which is modest extra value, but nothing about size limits, streaming, 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?

A single front-loaded sentence with no filler; every word carries information (action, scope, 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?

For a parameterless read tool with an output schema documenting the return value and readOnlyHint covering safety, the description is essentially sufficient. A note on scale (e.g. large libraries) would make it complete.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter semantics for the description to compensate for.

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), which clearly distinguishes it from import_opml_tool. It does not explicitly name the sibling, 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?

No statement of when to use this versus alternatives such as list_feeds_tool or import_opml_tool, nor any prerequisites. Usage is only inferable 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?

readOnlyHint=true already establishes this as a safe read, so the description's main added value is the note that entry counts are included in the response. It says nothing about what happens with an invalid or nonexistent feed_id, nor about auth requirements, and the output schema covers the return shape.

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; the resource and the notable return detail (entry counts) both appear immediately.

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 read tool with an output schema and readOnlyHint coverage, the description is nearly sufficient; only error/not-found behavior for a bad feed_id is 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?

One parameter with 100% schema description coverage; the schema already documents feed_id as a positive integer. The description adds no syntax, format, or constraint 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 and resource ('Get details for a single feed') and adds scope via 'a single feed,' which implicitly separates it from list_feeds_tool. It does not name any sibling explicitly, so an agent must infer the single-vs-list split.

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?

'Single feed' implies the use case of fetching one known feed by ID, contrasted with the listing tools, but there is no explicit when-to-use statement or mention of alternatives such as list_feeds_tool or get_stats_tool. Usage is inferable but not 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?

The readOnlyHint annotation already establishes this is a safe, non-mutating read, so the bar is lower. The description usefully enumerates the specific aggregates returned, but adds nothing about scope, refresh/freshness of the counts, or cost relative to listing tools.

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 first and the returned metrics immediately after the colon. No filler or restated title 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?

With no inputs, an output schema present, and safety covered by annotations, the description supplies everything an agent needs to decide to call it. The only omission is guidance on when this aggregate is preferable to the sibling list 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 tool takes zero parameters (additionalProperties: false), so there is nothing for the description to document. Baseline 4 applies; the metric list in the description loosely maps to the output schema rather than 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 ("Get") and resource ("dashboard stats") and enumerates the metrics returned (total feeds, unread count, entries per category). It is unambiguous about what the tool produces, though it does not explicitly note that it is the only stats/aggregate tool among the sibling listing 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing away from siblings such as list_feeds_tool or list_entries_tool. The agent must infer that this is a cheap aggregate summary versus making multiple list calls.

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?

The readOnlyHint annotation already establishes that this is a safe, non-mutating read, so the description carries a lower burden. "With feed counts" adds useful context about what the read returns, but it discloses nothing about ordering, completeness, or pagination behavior beyond that.

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 six-word sentence that front-loads the action and resource, with the only extra clause ("with feed counts") earning its place by clarifying the payload.

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 an output schema, an annotations-declared safety profile, and full schema coverage, the description supplies what an agent needs to select and call it. Minor gap: it does not say whether the list is exhaustive or scoped to the authenticated user.

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 for the description to disambiguate and the baseline is 4. No misleading parameter claims are made.

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 scope detail ("with feed counts") that distinguishes it from the category-mutation siblings like create_category_tool and rename_category_tool. It does not, however, explicitly contrast itself with list_feeds_tool or get_stats_tool, which also surface aggregate listing data.

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

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

Usage is implied by the verb: an agent can infer this is the call for enumerating categories. There is no statement of when to prefer it over get_stats_tool or list_feeds_tool, and no exclusions, so guidance is 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?

Annotations only declare readOnlyHint=true; the description goes further by disclosing that date-window filters compare against COALESCE(published, created_at), so undated entries still fall in a window by ingest time. That is real behavioral context an agent could not infer from the annotations or schema, though pagination/ordering behavior is 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?

Two short sentences with no filler, and the non-obvious COALESCE caveat is placed immediately after the topic sentence rather than buried. Nothing restates the tool name or the schema.

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 all 8 optional parameters are fully documented in the schema. The description's single job — conveying the surprising date-window semantics — is done, and the tool is read-only so no auth or destructive caveats are needed.

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 meaning the schema lacks: it explains the actual comparison column used by since_days/published_after/published_before, which changes how an agent interprets those bounds. It does not clarify the interaction between unread_only's true default and the date filters, so it stops short of a 5.

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') plus the fact that filters are optional, so the agent knows the shape of the call. However, it never distinguishes itself from the sibling search_entries_tool, leaving the boundary between plain listing and searching 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?

It gives one concrete usage instruction — use date-window filters to fetch a trailing period instead of paging through everything — which is genuine guidance for a subset of the call. But there is no when-not guidance and no routing to search_entries_tool, which is the obvious alternative for filtered retrieval, so usage is only partially covered.

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

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

The readOnlyHint=true annotation already declares this is a safe read operation, so the description need not carry the safety profile. It adds that unread counts are returned, which is behavioral value, but says nothing about ordering, pagination, or filtering behavior 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?

A single sentence that front-loads the action and the key payload (unread counts). No wasted words.

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

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

With an output schema, a fully documented parameter, and readOnly annotations, the definition is nearly complete. The remaining gap is that it does not route the agent relative to the many sibling list/get 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?

Schema description coverage is 100% and the single optional category_id is fully documented in the schema. The description adds no syntax or semantic 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+resource ("List all feeds") and adds the useful detail that unread counts are included. However, it does not distinguish itself from siblings like get_feed_tool or list_categories_tool, so the agent must infer the collection-vs-single 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 exclusions, and no reference to alternatives such as get_feed_tool (single feed) or search_entries_tool. The agent must decide purely 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 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the useful behavioral detail that the search spans titles and content, but says nothing about result ordering, ranking, or how the limit interacts with total matches.

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 filler; the scope constraint (titles and content) comes immediately after the verb. Nothing is wasted or buried.

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 readOnlyHint covers safety. For a search tool, though, the description omits ranking/ordering behavior and the relationship between the limit and total result count, which an agent calling this repeatedly would benefit from knowing.

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% – both parameters are documented in the schema, including FTS5 syntax support and the 1-500 limit range. The description adds no syntax, format, or default information beyond what the schema already 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+resource (full-text search across entries) and narrows the searchable fields to titles and content, which is more than the name alone conveys. It does not, however, differentiate itself from siblings like list_entries_tool or read_entry_tool, so an agent must infer the distinction from the verb 'search'.

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

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

No when-to-use, when-not, or alternative-tool guidance is given. The description never mentions list_entries_tool (enumeration) or read_entry_tool (fetch a single entry), leaving the agent to infer routing 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.