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 states the core behavior—returning warnings—and scopes them to interoperability/private URL/FreshRSS concerns, but it does not disclose whether the audit performs network fetches, has side effects, or requires special permissions. The word 'Return' implies read-only, but that is not explicit.

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 with no filler. Every word adds meaning: it states the action, the result type, and the domain-specific scope.

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 zero parameters and an output schema present, the description does not need to explain return shape or arguments. It covers the tool's purpose and specialized scope adequately. The main missing piece is usage context relative to sibling tools, but that is already accounted for in the usage_guidelines score.

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

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

The tool has zero parameters, so there is no parameter semantics burden on the description. The input schema is empty and needs no further explanation, leaving the baseline of 4 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 uses a specific verb ('Return') and resource ('interoperability warnings'), and adds useful specifics ('private URL/FreshRSS gotchas'). It is clear, but it does not explicitly distinguish itself from the sibling tool validate_feed, which could plausibly perform a similar audit role.

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

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

There is no guidance on when to call this tool versus validate_feed, rebuild_feed, configure_feed, or others. The description states what the tool does but not when it should be preferred or when an alternative is more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Update feed/channel configuration.' It does not explain whether patches are partial or full replacements, what happens on expected_revision conflicts, or what side effects occur on the existing feed.

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

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

The description is appropriately short and front-loaded, with no filler words. However, its extreme brevity veers toward under-specification rather than efficient completeness, leaving important behavioral and parameter context absent.

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?

This is a mutation tool with a complex nested configuration object and an optimistic-concurrency parameter, yet the description does not explain patch behavior, revision handling, or effects on the feed. The output schema doesn't compensate for the missing operational context.

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

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

Schema description coverage is 0%, and the description adds no parameter-level meaning whatsoever. It fails to mention the 'patch' object, 'expected_revision', or any of the FeedConfig fields, so an agent cannot infer parameter semantics from the description.

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 ('Update') and resource ('feed/channel configuration'), making the tool's core purpose clear and distinguishable from read-oriented siblings like get_feed. However, it doesn't elaborate on the configurable aspects or patch semantics, so it stops short of a fully differentiated definition.

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

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

There is no guidance on when to use this tool versus alternatives such as rebuild_feed or update_entry, nor any mention of prerequisites or the expected_revision mechanism. The description implies a configuration mutation context but provides no explicit when-to-use instructions.

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 of behavioral disclosure. It does reveal that the operation is visible (affects published state) and identity-preserving, but it doesn't say what happens to existing content, whether the correction note replaces or supplements content, how lifecycle is impacted, or whether feeds are affected. Significant side effects of a mutation like this are undisclosed.

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 sentence that front-loads the core purpose ('Publish a visible correction') and includes the key constraint ('preserving entry identity'). Every word earns its place; there is 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?

This is a mutation tool with no annotationsholistic, a required correction note, and a complex, optional patch object. The description omits essential context: what the correction note means, how the patch interacts with the correction, whether the tool changes lifecycle status, and what the output contains. The output schema exists but is not shown, and the description doesn't mention return values either. Given the tool's complexityeasier, this description is far from 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 schema has 3 top-level parameters with 0% description coverageable coverage. The tool description does not explain entry_id, correction_note, or patch at all. The phrase 'visible correction' hints that correction_note holds the correction text, and the EntryPatch definition in the schema partially explains patch, but the description itself contributes almost no parameter meaning. An agent would struggle to know how to construct a correct patch.

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 clear, specific action: publish a visible correction while preserving entry identity. It clearly references the resource (entry) and the operation (correct), setting it apart from a generic update. However, it doesn't explicitly name sibling tools like update_entry or retract_entry, so the differentiation is implicit rather than explicit.

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

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

The description gives no direct guidance on when to use this tool versus alternatives. It implies a scenario (need to correct an entry visibly while keeping its identity), but offers no exclusions or comparisons with create_entry, update_entry, or retract_entry. An agent is left to infer the appropriate context from the name and the one-line purpose.

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 of behavioral disclosure. It does reveal that a permanent urn:uuid ID is generated if omitted, which is useful, but it does not disclose what happens when an ID is supplied that already exists, whether creation is idempotent, or any validation or error behavior.

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

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

The description is a single focused sentence that front-loads the core purpose and adds the most important behavioral detail. There is 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?

The tool has a complex FeedEntry input schema, no annotations, and a sibling set of lifecycle-related tools, so the description should clarify revision semantics, ID-collision behavior, and the relationship to update_entry. None of that is present, leaving an agent under-equipped for correct invocation in non-trivial cases.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning only for the `id` subfield of `entry` (generation when omitted) and says nothing about `expected_revision` or the overall meaning of the `entry` payload beyond what the schema already names.

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 ('Create') and resource ('entry'), and the qualifier 'definitely-new' clearly distinguishes this from update_entry or republish_entry. It also signals the operation is an insert, not an upsert, which fully disambiguates the tool's core purpose.

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

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

There is no explicit guidance about when to choose create_entry over update_entry, correct_entry, or republish_entry. The phrase 'definitely-new' implies the tool is for new entries rather than modifications, but no exclusions or alternative routing are stated, leaving an agent to infer the selection criteria.

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

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

With no annotations provided, the description carries the behavioral burden, and it does add meaningful context: results are restricted to active/published entries and are explicitly candidates, not authority to merge. It does not mention matching thresholds or pagination, but the core read-only retrieval behavior and output boundary are disclosed.

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

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

Two sentences with no filler, and the primary scope ('only among currently active/published entries') is front-loaded. Every phrase adds distinct value.

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

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

For a tool with three optional parameters and a complex nested FeedEntry object, the description leaves call construction underspecified. The output schema may cover return values, but the agent still lacks enough information about valid query combinations and the meaning of limit to call the tool confidently.

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

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

The schema has 0% description coverage, and the prose never explains the roles of text, entry, or limit. An agent cannot tell whether text and entry are alternatives, whether entry must contain certain fields, or what limit controls beyond the schema's default. The description does not compensate for the missing parameter documentation.

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

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

The description uses a specific verb ('Find') and a clear resource ('semantic candidates ... among currently active/published entries'), and it explicitly distinguishes the tool's output from a merge decision. This makes it easy to tell apart from sibling tools like list_active_entries, which lists entries without semantic ranking.

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 gives no guidance about when to prefer this tool over siblings such as list_active_entries or get_entry. The only usage signal is implicit: use it when you need semantic candidates. It never states what scenarios call for this tool or when an alternative would be more appropriate.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clarifies that this is a read/retrieval operation and does not perform uploads, which is useful. However, it does not mention error behavior, authentication requirements, or what happens if the asset_id does not exist, leaving some behavioral gaps.

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

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

Two short sentences with no filler. The primary purpose is front-loaded, and the clarifying note about uploads earning its place by preventing a common misuse.

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

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

For a simple one-parameter getter with an output schema, the description covers the essential purpose and boundary. It lacks parameter guidance and error semantics, but the tool's low complexity and existing output schema make it reasonably complete for correct invocation.

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

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

Schema description coverage is 0% and the description does not explain asset_id beyond the schema's title. It does not say how to obtain the asset_id, its expected format, or whether it corresponds to an upload response field. The parameter is self-explanatory by name, but the description adds no semantic value.

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

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

The description uses a specific verb ('Return') and names the exact resource ('metadata/public URL for an already-uploaded asset'). It also distinguishes itself from the binary upload operation by explicitly stating that uploads happen over the HTTP asset API, making the tool's scope unambiguous even among siblings.

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

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

The description clearly indicates this is for retrieving an already-uploaded asset's metadata/URL, and it explicitly routes upload behavior to a different API. It does not name alternative sibling tools or state when not to use it, but the context is sufficient for an agent to select it for retrieval tasks.

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 ('Return') but does not explicitly state that it has no side effects, does not modify data, or require specific permissions. It also does not mention error behavior if the ID is invalid.

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 concise sentence, front-loaded with the primary purpose, with no filler words.

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

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

For a simple read operation with one parameter and an output schema, the description covers the essential purpose. However, it lacks explicit side-effect disclosure (though likely read-only) and error conditions, which are minor given the simplicity.

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

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

The schema provides only the name 'entry_id' with 0% description coverage. The description adds meaning by calling it an 'immutable ID', clarifying its nature, but it does not provide format, examples, or constraints.

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

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

The description states a specific action ('Return'), a clear resource ('FeedEntry'), and identifies the key as an 'immutable ID'. This distinguishes it from sibling tools that operate on feeds, assets, or lists of entries.

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 provided on when to use this tool versus alternatives like list_active_entries or get_feed. There are no explicit conditions, exclusions, or alternative tool mentions.

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 behavioral burden. 'Return' implies a read-only operation and naming 'current revision' adds useful context, but it never explicitly states that the call has no side effects or what happens if no feed is configured.

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 sentence with no filler; the verb and the returned items are front-loaded. Every word contributes meaningful information.

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

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

For a zero-parameter getter with an output schema present, the description gives an agent everything needed to invoke it correctly. Return values are already covered by the output schema, so no further explanation is required.

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

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

The input schema has zero properties, so there are no parameter semantics to clarify. With no parameters, the baseline of 4 applies and the description does not need to add parameter detail.

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

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

The description names a specific verb ('Return') and resource ('feed configuration, current revision, and publication URL'), so an agent understands what the tool outputs. It does not explicitly differentiate from sibling tools like validate_feed or get_asset, so it misses 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 provides no guidance about when to call this tool versus siblings such as validate_feed, audit_feed, or get_asset. 'Return' implies retrieval, but there are no explicit usage criteria or exclusions.

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

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

With no annotations, the description carries the behavioral burden. It conveys a read-only style operation through 'Return' and discloses output granularity ('compact summaries') and temporal scope ('currently emitted'). It does not mention ordering, pagination, or snapshot consistency, but there is no suggestion of side effects.

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, focused sentence with no wasted words. The action, resource, scope, and output format are all front-loaded and necessary.

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

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

For a zero-parameter read-only listing operation with an output schema present, the description is largely sufficient for an agent to invoke it correctly. The only real gap is explicit sibling routing guidance, but that is already accounted for in usage_guidelines.

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

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

The tool has zero parameters and the schema coverage is 100%, so the description does not need to explain parameters. The baseline of 4 applies because no parameter meaning is 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 action ('Return compact summaries'), a clear resource ('entries currently emitted into feed.xml'), and a scoping constraint ('currently emitted'). The compact-summary wording also signals the output shape. It does not explicitly contrast with siblings like get_entry or get_feed, but the scope is precise enough to distinguish 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 'currently emitted into feed.xml' phrase implies the tool is for inspecting the live feed entry set, so usage context is inferable. However, there is no explicit when-to-use statement, no exclusions, and no direction to alternatives such as get_entry or find_similar_active_entries.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose two useful traits beyond the name — operations are applied in a single publisher transaction and a rebuild is triggered exactly once — which tells the agent this is a mutating, side-effectful batch call. But it omits partial-failure behavior, expected_revision conflict handling, and the fact that this affects live published content, so the disclosure is only partial.

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 dense 13-word sentence with the action and resource front-loaded and zero filler words. It is efficient for what it covers, though it is terse relative to the tool's complexity; the resulting omissions are more appropriately penalized under contextual completeness than here.

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 complex batch mutation tool with no annotations, one sentence does not fully equip an agent: it leaves out expected_revision semantics, atomicity guarantees on partial failure, and routing guidance versus create_entry/update_entry/rebuild_feed. The presence of an output schema covers return values, but the key behavioral and decision context is missing given the schema's substantial $defs complexity.

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

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

Schema description coverage is 0%, so the description was expected to compensate, and it adds nothing about the operations array or expected_revision. The schema's own embedded descriptions partly mitigate this (BatchOperation: 'One create/update/upsert operation inside publish_batch' and the detailed EntryPatch rationale), but expected_revision is entirely undocumented at both layers — the description never hints at its optimistic-concurrency role.

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 action ('Apply') and resource ('multiple creates/updates') and adds distinguishing scope: 'in one publisher transaction and rebuild once' separates it from single-entry siblings like create_entry and update_entry, and from a manual rebuild_feed call. It loses a point because it omits the 'upsert' operation that the BatchOperation schema explicitly supports, slightly understating the tool's full scope.

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

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

The phrasing 'multiple creates/updates in one transaction and rebuild once' implies the tool is for batching several operations into a single atomic publish cycle, which implicitly contrasts with the single-entry tools in the sibling list. However, it never names an alternative, states when not to use it, or explains when to prefer publish_batch over create_entry/update_entry, leaving routing to inference.

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

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

There are no annotations to carry the burden of behavioral disclosure. The description reveals that the operation is deterministic and reads from SQLite, but it does not state whether this overwrites existing public artifacts, requires special permissions, or has side effects on published feeds. 'Regenerate' implies mutation but the consequences are undisclosed.

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 compact sentence with no filler. It front-loads the main action and avoids redundant restatement of the tool name. The brevity is appropriate given there are no parameters to document.

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

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

Despite having an output schema and no parameters, the description lacks critical context. It does not explain what 'public artifacts' are, what effects regeneration has on the live feed, when this should be run, or why it would be preferred over publication or validation siblings. An agent would likely need additional information to invoke this safely and correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description adds context by naming the data source but does not need to explain parameter meanings. No parameter documentation gap exists.

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

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

The description uses a specific verb ('Regenerate') and identifies both the source ('authoritative SQLite state') and the output ('deterministic public artifacts'). It is clearer than a bare tautology and differentiates from siblings like validate_feed or audit_feed by implying a regeneration action, though 'public artifacts' is somewhat vague and not explicitly linked to feeds.

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

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

No guidance is given on when to use this tool instead of siblings like publish_batch, correct_entry, or get_feed. The phrase 'from authoritative SQLite state' hints at a precondition but does not state concrete triggers, alternatives, or exclusion criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the main state transition but does not disclose side effects such as whether history is preserved, whether permissions are required, whether the operation is reversible, or how already-active entries are handled.

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

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

A single sentence with no filler, front-loaded with the key action word 'revive.' Every part of the sentence contributes meaning.

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

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

For a one-parameter tool with an output schema, the description is close to sufficient, but with no annotations and a large sibling set, it lacks guidance on when alternatives should be preferred and what side effects to expect. It is adequate as a minimal definition but has clear gaps.

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

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

Schema coverage is 0%, but the description partially compensates by implying entry_id refers to an archived/unpublished entry. It does not explain the ID format, how to obtain it, or the exact semantics of 'archived' versus 'unpublished,' leaving some inference to the agent.

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

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

The description uses a specific verb ('revive') and clearly identifies both the source state ('archived/unpublished') and target state ('active feed'). This makes it easy to distinguish from reverse operations like unpublish_entry and from batch operations like publish_batch.

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 'archived/unpublished' qualifier implies when the tool should be used, but there is no explicit when-not-to-use guidance or mention of alternatives. An agent can infer the intended use case, but not the boundary against siblings like publish_batch or correct_entry.

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 states the retraction is 'explicit' and under an 'immutable entry ID', suggesting permanence, but does not disclose the implications of retraction, such as whether it makes the entry inaccessible, deletes it, or affects related assets. The agent is left with incomplete information about the consequences.

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 sentence, concise and front-loaded with the core action. It lacks unnecessary fluff, but its brevity contributes to the lack of detail.

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

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

Given the complexity of a retraction action and the low schema coverage, the description is incomplete. It does not explain the behavior of the retraction (e.g., visibility, reversibility), nor does it address the 'reason' parameter, nor any expected output beyond the output schema. The description fails to provide a complete picture for a tool with potential side effects.

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

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

Schema description coverage is 0%, so the description must explain parameters. It explains the entry_id is used as the immutable ID, but says nothing about the 'reason' parameter—its purpose, format, or whether it is required for retraction. This leaves the agent guessing about the optional reason field.

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 the tool publishes an explicit retraction under an immutable entry ID. This clearly indicates the action (retraction) and the resource (entry), distinguishing it from update or unpublish siblings. However, it does not explicitly mention the verb 'retract' or differentiate from correct_entry.

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

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

The description implies the tool is for retracting an entry, but does not provide explicit guidance on when to use it versus alternatives like 'unpublish_entry' or 'correct_entry'. It lacks details on when a retraction is appropriate or what distinguishes it from other actions.

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 of behavioral disclosure. It does add a valuable nuance—unpublishing does not delete copies already stored by RSS subscribers—but it omits other useful behaviors such as side effects on feeds, reversibility, idempotency, or permissions.

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, purposeful sentences with no wasted words. The primary action is front-loaded and the clarifying non-deletion note directly follows, making the description easy to process.

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, has one parameter, and an output schema exists, so return-value documentation is unnecessary. Still, the description does not provide enough contextual guidance for an agent choosing among the publisher sibling tools, leaving it minimally viable rather than 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 schema lacks parameter descriptions and the tool description does not compensate. It refers to 'an entry' but does not clarify what entry_id must refer to, what format is expected, or any constraints beyond the property name. For a single required parameter this is a modest but real gap.

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

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

The description names a specific action ('Stop emitting an entry') and a clear resource, and it adds a meaningful constraint: existing RSS subscriber copies are not deleted. However, it does not explicitly differentiate this from sibling tools like retract_entry, so the agent must infer where unpublish fits.

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

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

There is no guidance on when to use unpublish_entry versus retract_entry, republish_entry, or publish_batch. The RSS-copies note hints at the intended context, but the agent is not told under what conditions this tool should be selected over alternatives.

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

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

With no annotations, the description carries the burden and does add behavioral context: patch semantics, immutable ID preservation, and the active-only constraint. But it omits key behavioral details such as expected_revision optimistic concurrency, side effects, permission requirements, and response behavior.

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

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

Two sentences with no filler. The core action and primary constraint are front-loaded, and the archived-entry alternative is stated efficiently.

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

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

The output schema presumably covers return values, and the EntryPatch definition covers the partial-update model. Still, the tool has an expected_revision parameter that is left unexplained, and no annotations exist to cover safety or concurrency context, so the description is not fully complete for a mutation tool of this complexity.

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

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

Schema description coverage is 0%, so the description should compensate for parameter meaning, but it mentions none of entry_id, patch, or expected_revision. The embedded EntryPatch schema description explains patch fields, but the tool description itself adds no parameter semantics.

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

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

States a specific verb ('Patch'), a resource ('entry'), and a scope ('active'), and adds that the ID is immutable. This clearly differentiates update_entry from creation, deletion, and lifecycle-specific siblings like retract_entry or unpublish_entry.

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 gives an alternative for archived entries ('republish_entry first'), which is actionable when-to-use guidance. However, it does not distinguish update_entry from correct_entry, retract_entry, or unpublish_entry, so the routing guidance is not exhaustive.

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 present, so the description must carry the full burden of behavioral disclosure. The phrase 'strict local' implies a read-only, non-destructive validation operation and rules out remote validation, but it does not state whether validation returns a report, throws errors, or modifies anything. This is thinner than expected for a tool with zero annotation coverage.

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

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

The description is a single concise phrase, 'Strict local RSS/XML validation,' with no filler words. It front-loads the core action and resource, and every word earns its place. Though terse, it is an efficient use of the description field.

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 has zero parameters, so no parameter documentation is needed, and an output schema exists to specify return values. However, the description does not clarify what object is being validated (e.g., the currently staged feed, a local file) or what 'strict' entails. For a simple no-arg tool this is a minor but real 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 input schema is empty (0 parameters), so there are no parameter semantics to explain. The description correctly avoids inventing parameters, and per the rubric a zero-parameter tool receives a baseline of 4. Nothing in the description conflicts with 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 clear action and resource: validation of RSS/XML, with 'strict' and 'local' adding specificity. It distinguishes itself from siblings like audit_feed or configure_feed because only this tool is explicitly a validator. It is not a full sentence, but it is not a tautology and an agent can tell what the tool 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?

The description offers no guidance on when to use validate_feed versus any of the siblings. There is no mention of preconditions, recommended workflow (e.g., before publish_batch), or alternatives. The agent is left to infer the use case 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.