AgingResearch.News

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

Goes meaningfully beyond the annotations by disclosing the quota cost ('Spends one of the user's Ask questions for the day'), the answer shape (~350 words, numbered sources, states when its record is thin), and the asynchronous fallback to get_ask_answer. The openWorldHint explains why answers may be thin, but nothing is said about what happens when the quota is exhausted.

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

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

Front-loaded with the selection condition and tightly packed with decision-relevant facts; nearly every clause earns its place. Some sentences are run-on (the parenthetical examples and the record/papers list), which slightly hurts scannability.

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

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

With no output schema, the description still covers the return shape (length, numbered citations, honesty about thin coverage), the async answer-retrieval path, the quota side effect, and the follow-up mechanism. An agent has everything needed to call it, wait, or retrieve the result.

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 are already fully documented, including language handling and the conversation_id pattern. The description's 'Pass conversation_id for a follow-up' only restates the schema rather than adding new semantics, 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 ('written, cited answer') and resource ('research question on the biology of aging...'), and immediately contrasts with the sibling that returns papers: 'rather than a list of papers... For the papers themselves, use search_papers.' An agent can route between ask_arn and search_papers without opening either schema.

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

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

Explicit positive triggers with worked examples ('does rapamycin extend lifespan in people, who works on epigenetic clocks'), an explicit exclusion ('Not for personal medical advice, doses or symptoms'), a named alternative for the list case, and follow-up routing via conversation_id plus get_ask_answer when the answer is not ready.

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 cover the read-only/idempotent/safe profile, and the description adds non-obvious behavioral context: plans covering both drugs and therapies force a full-record read while others read an outline, implying a cost/latency difference. It does not describe the return shape or pagination behavior beyond the limit parameter.

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

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

Three sentences, front-loaded with the trigger, then grouping capability, then the filter example and cost note. Dense and largely waste-free, though the final clause ("as on the site") is slightly cryptic for an agent without site context.

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 12 optional parameters and full schema coverage, the description does the heavy lifting on grouping and filter composition and flags read cost. The main remaining gap is that no output schema exists, so the exact aggregate response shape (counts per group, paging) is only implied by "counts programs by stage."

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 baseline is 3, but the description earns extra credit by explaining filter interaction semantics beyond the schema: filters are inherited from list_assets, and grouping by target combined with an indication filter counts the targets of that indication's programs. That is meaning the schema alone does not convey.

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 (counts) and resource (drug and therapy programs) plus the exact grouping dimensions available. It also implicitly contrasts with list_assets, which returns records rather than aggregates, so an agent can pick between them without opening either schema.

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

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

"Use this when the user asks how many..." is an explicit trigger condition, and the worked example (by=target with indication=obesity) shows a concrete call shape. It stops short of saying when NOT to use it or naming list_assets as the alternative for record retrieval, so it is clear context without explicit 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?

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral detail beyond that: case-insensitive substring matching, synonym matching, exact most-studied first ranking, MeSH headings last, and paper counts per entity.

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

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

Three sentences, front-loaded with the core use case and followed by matching behavior and next-step guidance. The long parenthetical entity list is informative rather than wasteful.

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

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

With no output schema, the description discloses that results carry type, key, and paper counts, and the schema covers pagination via cursor. It does not fully describe the response envelope, but it gives enough to invoke and use the tool correctly.

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

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

Schema description coverage is 100%, so q, type, limit, and cursor are fully documented in the schema. The description mostly restates q's matching and ranking behavior and adds onward-passing advice, so the baseline 3 is appropriate.

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

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

States a specific verb and resource: find entities by type and key, with a clear list of entity categories. It distinguishes itself from get_entity, list_claims, and list_grants by positioning itself as the preliminary lookup before those 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?

Explicitly says to use this before get_entity, list_claims, or list_grants, and explains passing the result's type and key onward. It lacks an explicit when-not condition, such as using get_entity directly when the key is already known, so it stops short of full alternative guidance.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, so the safety profile is covered; the description adds real value by describing the concrete side effect – new papers delivered to 'For you' and a daily follow email. It omits permission/auth requirements and what happens on a repeat follow, but the idempotent hint covers the latter.

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, zero filler, and the trigger condition is front-loaded ahead of the parameter-sourcing note and the effect. Every sentence carries information the agent needs.

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 two-parameter, non-destructive, idempotent mutation with no output schema and full annotation coverage, the description supplies the trigger, the argument source, and the user-visible effect. Nothing essential to invoking it correctly is missing.

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

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

Schema coverage is 100% (both params documented, type has a full enum), so the baseline is 3. The description earns an extra point by telling the agent where the values come from – find_entities or get_entity – which is not encoded in the schema and prevents guessed keys.

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 (follow) and resource (an entity on AgingResearch.News) plus the observable effect (new papers arrive in For you and the daily follow email). It does not name the direct counterpart `unfollow` or `list_follows`, so sibling differentiation rests on the tool name rather than the description; the prose also uses 'drug/process' where the enum says 'intervention/pathway', a small terminology drift.

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

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

'Use this when the user asks to follow a ... entity' gives a clear triggering condition, and 'Takes a type and key from find_entities or get_entity' routes the agent to the upstream tools that supply the required arguments. It stops short of stating when NOT to use it (e.g. already-followed entities, or use unfollow instead), so no explicit 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?

Beyond the readOnly/idempotent annotations, the description discloses important behavior: it waits up to 20 seconds for a short answer that is nearly done, returns status if the answer is not ready, and notes that an Ultradeep review takes several minutes. These details materially affect how the agent should invoke and interpret the tool.

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

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

The description is a single dense sentence with no filler. The usage condition is front-loaded, and the waiting behavior follows immediately, making it easy for an agent to parse.

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

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

With no output schema, the description still explains what is returned: the answer with numbered sources once written, or the current status otherwise. It also covers the key timing caveat for short versus Ultradeep answers, which is enough 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 100%, and the schema already explains that question_id comes from ask_arn or start_ultradeep. The description does not add syntax, format, or edge-case guidance beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource: reading the answer for a question. It distinguishes itself from ask_arn, start_ultradeep, and list_questions by explaining that it returns the written answer with numbered sources or the current status.

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 explicitly says when to use it: when ask_arn or start_ultradeep indicates the answer is still being written, or when the user wants the answer again. This gives the agent clear routing conditions rather than leaving usage 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 already declare read-only, idempotent, closed-world behavior, so the description is not responsible for safety semantics. It adds useful behavioral context by describing the returned record depth and noting that some plans read full records while others get an outline.

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

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

The description is front-loaded with the triggering condition and then lists the relevant record contents efficiently. The final sentence about plans reading records in full versus as an outline is somewhat vague, but overall the structure is deliberate.

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

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

There is no output schema, but the description thoroughly enumerates what the record contains: developers, targets, mechanism, indications, designations, patents, catalysts, and recent events. Combined with the fully documented single parameter and safety annotations, it is complete enough for an agent to call it correctly.

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

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

Schema coverage is 100%, and the key parameter is already documented as the asset key or code name. The description reinforces the code-name format with examples, but adds little beyond the structured schema.

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

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

The description states a specific retrieval action for one drug or therapy program by name or code name, and enumerates the record facets it covers. The singular scope implicitly distinguishes it from list-oriented siblings such as list_assets.

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 a clear triggering condition: use when the user asks about one drug or therapy program by its name or code name. It does not explicitly name alternatives like list_assets or state when not to use it, but the usage context is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds two useful things beyond that: the two operating modes (with and without `edition`) and the caveat that an abstract is not a peer-reviewed paper. It says nothing about pagination behavior or result ordering, keeping it at a solid but not rich level.

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

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

Front-loaded with the usage trigger and no filler sentences; the closing caveat about abstracts earns its place. The main sentence is long and semicolon-chained, making it slightly harder to parse than it needs to be.

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 5-parameter read-only tool with annotations covering safety and no output schema, the description covers modes, return content and a semantic caveat. It omits any mention of pagination or how the two modes interact with `limit`/`cursor`, though the schema documents those fields directly.

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 baseline is 3, but the description earns an extra point by explaining the mode switch: `edition` turns the call into an abstract listing and couples with `min_visibility`. That conditional relationship is the one thing the schema fields alone don't make obvious.

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

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

Specific verb (get) plus resource (a conference) with an explicit statement of what is returned: organizer, site and editions, and with `edition` that edition's abstracts plus the paper each was published as. It distinguishes itself from the sibling list_conferences by naming it as the source of the id.

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

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

Gives a clear trigger: the user asks about one meeting from list_conferences or what was presented there. It names the sibling that supplies the id but never explicitly states when to prefer list_conferences over this tool, so the exclusion is left to inference.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds substantive context beyond them: papers are returned newest first with each paper's role, `evidence` is structured and never a grade, and counts reflect only papers AgingResearch.News has read rather than all literature. That last caveat materially shapes interpretation of the results.

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

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

The opening cue sentence and the find_entities sourcing note are front-loaded, with caveats and exclusions trailing sensibly. The long enumeration of example questions is dense but each item maps to a distinct capability, so little is wasted, though it is on the longer side.

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

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

There is no output schema, so the description carries the return-shape burden, and it does: entity plus papers, newest first, per-paper role, and the nature of `evidence`. With annotations covering the safety profile, an agent has everything needed to call this correctly and interpret the response.

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 semantics the schema lacks: it explains that type/key come from find_entities and illustrates valid pairings ('intervention rapamycin'). It does not discuss limit, cursor, or min_relevance in prose, though those are fully documented in-schema.

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

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

The description states a specific verb+resource (retrieve one entity and its papers) and enumerates the entity kinds covered (drug, supplement, gene, process, disease). It explicitly contrasts with find_entities as the discovery step that supplies type and key, so an agent can distinguish it from siblings without opening a schema.

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

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

It gives the triggering condition ('questions about one drug, supplement, gene, process or disease'), names the upstream alternative ('Takes a type and key from find_entities (intervention rapamycin)'), and states an exclusion ('Not for personal medical advice or doses'). Both when-to-use and when-not are present.

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

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

Annotations already declare this as a safe, read-only, idempotent operation, and the description adds substantial behavioral context: it explains what information is returned, including aging relevance, language and title handling, author details, paper story, studied entities, findings, and a source link. It also clarifies that it does not replace the paper itself.

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

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

The description is front-loaded with the usage condition, followed by input and return details. Despite being fairly rich, every sentence serves a purpose by clarifying when to use it, what input it accepts, and what the agent should expect back.

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

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

There is no output schema, so the description must carry the return-value burden, and it does so thoroughly. Combined with annotations that cover safety and idempotency, the definition gives an agent enough context to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, and the schema already documents the accepted id formats in detail. The description reinforces that the id can come from another tool's results or be a DOI, PMID, PMCID, arXiv id, or link, but it does not add syntax or semantics beyond the schema.

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

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

The description uses a specific verb and resource: it tells the agent this tool retrieves one paper in depth. It clearly distinguishes the tool from list/search tools by emphasizing a single paper and its full details, so an agent can identify it without opening the schema.

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

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

It gives a clear usage condition: 'when the user wants one paper in depth.' It also explains accepted identifiers, including ids from other tools and standard paper identifiers. It does not explicitly name alternatives like list_papers or search_papers, but the single-paper scoping makes the intended use clear.

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 readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new context: the response includes the full change history and citing papers, and the answer should surface WHO ICTRP attribution plus the WHO processing date — a provenance constraint the annotations cannot express.

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, front-loaded with the usage trigger and then the return content, with no filler. The second sentence is dense and slightly clipped ('Show a WHO ICTRP record with its attribution') but every clause carries real instruction.

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 lookup with no output schema, the description covers trigger, scope, returned content and provenance/attribution handling. The only remaining gap is failure behavior — an unknown or malformed registry number — which the description does not address.

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

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

Schema coverage is 100% and the nct_id field already carries a pattern and examples, so the baseline is 3. The description goes beyond it by naming the accepted identifier namespaces (NCT, ISRCTN, ChiCTR, CTRI, CTIS 'and others'), which tells the agent the parameter is not NCT-only despite the field being named nct_id.

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 a clinical trial') and narrows the scope to exactly one trial looked up by registry number, which cleanly separates it from list_trials. It also enumerates the payload ('design, outcomes and dates, every change recorded and the papers that cite it'), so the agent knows the shape of the result before calling.

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

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

'Use this when the user asks about one clinical trial by its registry number' gives an explicit trigger condition and an implicit alternative (list_trials for browsing). It stops short of naming that sibling or stating what to do when the user only has a title or sponsor rather than an identifier.

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 cover the safety profile (readOnly, idempotent, non-destructive), and the description adds sort order ('furthest stage first') plus the returned field set. The line about a plan 'reads every record in full; others read an outline' discloses a real result-shape quirk, though it is worded vaguely enough that the agent may not be certain how it applies.

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

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

Three sentences, front-loaded with the triggering user intent, then results, then routing. The inventory of returned fields is long but functional; no sentence is pure filler.

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

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

With 12 optional parameters and no output schema, the description compensates by listing what comes back and in what order. Coverage is good, though the 'reads every record in full' clause could be clearer about its practical effect on the response.

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 four enums documented inline, so the schema carries the parameter burden. The description adds no filter syntax, combination behavior, or default rules beyond what the schema already states, which is the baseline case for a fully documented schema.

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

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

States a specific verb and resource ('list' + 'drug and therapy programs') and enumerates the exact user question it answers (what's in development against a target, mechanism, hallmark or disease, and who develops it). The title and first sentence together make it unmistakable next to siblings like get_asset or count_pipeline.

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 names the alternative tools and when to use them: 'Read one with get_asset; count them with count_pipeline.' That is a direct when/when-not routing rule an agent can act on without opening either schema.

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

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

Annotations already establish that this is a safe, idempotent, read-only list operation. The description adds useful behavioral context: results are extracted claims with organism, effect size and paper, ordered newest first, and should be followed up via get_paper. It does not explain pagination beyond the schema, but it meaningfully supplements the annotations.

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 compact and front-loaded: usage trigger first, then what the data looks like, then the follow-up tool and exclusion. Every sentence earns its place.

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

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

With no output schema, the description explains the returned fields and ordering sufficiently for an agent to understand what a result looks like. The optional filters are documented in the schema, and the description covers the purpose, data shape, ordering, and next step.

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 conceptual meaning by explaining that claims are structured as subject, relation and object, with organism and paper metadata. It does not explain limit/cursor, but those are fully described in 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 names the specific resource (findings/claims extracted from papers) and explains their subject-relation-object structure with a concrete example. It clearly distinguishes this from paper lookup by telling the agent to use get_paper for details on a specific finding.

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 explicit when-to-use guidance with example questions and a clear exclusion (not for personal medical advice). It also names get_paper as the detail-lookup alternative, though it does not explicitly compare against search_papers or list_papers.

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 readOnly, idempotent, non-destructive, closed-world behavior, so the description's added value is the return shape: ordered calendar plus per-edition dates, place and abstract count. It doesn't say whether results are capped or paginated, a minor gap given zero parameters.

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 trigger condition, then ordering, then the next-step pointer. No redundant restatement of the title or annotations.

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

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

With no output schema, the description does the work of explaining what comes back (conference editions with dates, place, abstract presence) and their order. It stops short of stating result volume or whether the calendar is bounded, which for a zero-arg list tool would fully close the loop.

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 no parameters, so there is nothing for the description to disambiguate; baseline for a zero-parameter tool is 4. The description correctly implies no filtering/date-range arguments are needed.

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

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

States a specific verb (list) and resource (conferences in aging research / age-related disease), including the ordering rule (soonest first, then recent). It also names the sibling used to drill into a single item, so the agent can distinguish list_conferences from get_conference without opening either schema.

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

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

The opening clause gives an explicit trigger ('when the user asks which meetings ... are coming up or were just held'), and the closing sentence routes the agent to get_conference for detail. Both when-to-use and the alternative are 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds real context beyond that: result ordering (newest first), that each item carries its page, and that ids use a type:key form consumed by unfollow.

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 dense sentence with the trigger front-loaded and zero filler; every clause (contents, ordering, page, id format) contributes information an agent needs.

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

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

There is no output schema, yet the description still conveys the return shape — entity and saved-search items, newest-first ordering, per-item page, and id format — which is exactly what an agent needs to interpret results.

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 no parameters, so the baseline is 4; there is nothing for the description to disambiguate 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?

Names a specific verb (list) and resource (follows) and enumerates the contents — entities and saved searches — plus ordering (newest first). It partially differentiates from siblings by tying the returned entity id to the format unfollow expects, though it doesn't contrast with other list_* 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?

'Use this when the user asks what they follow' gives an explicit trigger condition, and the mention of unfollow's id format implicitly signals that mutations belong to a different tool. No explicit when-not statement, but the context is clear.

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 readOnly/idempotent/non-destructive/closed-world, so the description focuses on domain behavior: the corpus is limited to aging research and four funders, and results come back newest award first. It does not discuss result caps or how paging terminates beyond what the cursor param already says, so it stops short of a 5.

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

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

Three sentences, zero padding, front-loaded with the trigger condition before the data description and the sibling redirect. Every clause carries either routing or content 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?

With no required parameters, no output schema and full schema coverage, the description supplies exactly what is missing: what a result record contains, the funder coverage, and the default ordering. An agent has everything needed to call and interpret it.

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 all eight parameters are already documented with examples and formats. The description only lightly gestures at the date filters ('since when') and does not explain entity/funder/holder semantics or query syntax, so it adds little beyond the schema – 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 names a specific verb and resource ('List ... research grants') and immediately scopes it: aging research grants from NIH, CORDIS, UKRI and Wellcome, sorted newest-first, with an explicit field inventory. An agent can distinguish it from generic paper or trial tools without opening the schema.

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

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

It states the triggering user question ('who funds work on a target, drug, process or lab, how much and since when') and names the boundary case plus the alternative: 'For company financings use list_news.' Both when-to-use and when-not-to-use are explicit.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds real behavioral detail beyond them: deduplication to one story per event, newest-first ordering, and aggregation of every outlet that covered the story. It does not mention rate limits or what an empty result looks like, keeping it below a 5.

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

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

Three tight sentences, no filler, with the usage condition front-loaded and the exclusion placed at the end where it reads as a clean boundary.

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

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

With no output schema, the description carries the return shape and does so adequately — one story per event, sorted newest first, with outbound links. Pagination is covered by the schema's cursor field, so nothing an agent needs to invoke the tool is missing.

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

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

Schema description coverage is 100%, so q, kind, limit, since, and cursor are already fully documented. The description adds no parameter-level detail beyond reinforcing "newest first" ordering, 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 (list news) and narrows it to aging research / longevity industry events, enumerating the covered event types (financings, trial readouts, approvals, policy, conferences). It also excludes general and market news, though it does not differentiate itself from the sibling list_stories.

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

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

"Use this when the user asks about events in aging research and the longevity industry" gives an explicit trigger, and "Not for general or market news" gives an explicit exclusion. It stops short of naming which sibling tool to use for the excluded cases.

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 read-only, idempotent, non-destructive behavior. The description adds useful context beyond that: results are ordered 'Newest first by the date AgingResearch.News added them' and the tool supports 'search_papers' filters and an optional words filter.' It does not describe return format or pagination, but the added ordering semantics are meaningful.

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 two tightly written sentences with zero waste. The primary use case is front-loaded, followed immediately by the alternative, and every phrase earns its place.

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

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

For a 12-parameter read-only list tool with full schema coverage and safety annotations, the definition is nearly complete: it explains selection criteria, ordering, and the sibling alternative. It stops short of describing pagination or return fields, but those gaps are minor given the absence of an output schema and the presence of a documented cursor parameter.

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

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

Schema description coverage is 100%, so every parameter is fully documented in the schema. The description generically references 'search_papers' filters and an optional words filter' but adds no syntax or constraints beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states a specific verb (list) and resource (papers), specifies the scope of 'new' papers by field, study type, body system, or author, and explicitly distinguishes this tool from search_papers. An agent can immediately tell what this tool returns and how it differs from its 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?

It gives an explicit trigger ('Use this when the user asks what is new') and a clear alternative rule ('For the papers that best answer a question, use search_papers'), covering both when to use this tool and when not to.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive behavior, and closed-world scope. The description adds useful ordering ('newest first') and return-content context ('title and address'), but it does not explain pagination, limits, or what happens beyond the returned set.

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 gives the usage trigger and then the key output traits. There is no wasted text.

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-optional-parameter read tool with rich annotations and no output schema, the description covers when to call it, ordering, and the main returned fields. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100% and the single limit parameter is fully documented with default, min, and max. The description does not add any meaning beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb and resource: listing the user's previously asked AgingResearch.News questions. It also clarifies scope ('their recent conversations, newest first') and return shape, so an agent can distinguish it from answer-fetching or content-listing 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 opening clause gives a clear trigger: use when the user asks about questions they asked before. It does not explicitly name when to avoid it or which sibling to use for direct answer retrieval, so it falls short of full alternative routing.

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

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

Annotations already declare readOnly/idempotent/non-destructive and closed-world, so the safety profile is covered. The description adds genuine context beyond that: results are newest-first and each story is checked against and paired with its source paper, which shapes how an agent should present output. It stops short of describing pagination or result volume, which the schema partially covers via `cursor`.

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

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

Front-loaded with the trigger condition, with the sibling contrast placed last where it belongs. Slightly dense in the middle clause ('each checked against its paper and given with it'), which reads awkwardly, but no sentence is filler.

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

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

For a 7-parameter, zero-required read tool with no output schema, the description covers what the agent most needs: what the records are, their ordering, their provenance, and the alternative tool. What's missing is any hint about the richness of filtering options available, so an agent may not realize it can scope by body system or category.

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 each parameter (limit, since/until, cursor, system, category, study_type) is well documented inline, so baseline 3 applies. The description adds no filter guidance — nothing about how `system`, `category`, or `study_type` interact with the 'round-up' use case, missing a chance to explain that these filters exist and when to narrow with them.

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

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

States a specific verb (list) and resource (plain-language stories about new papers from AgingResearch.News), plus ordering ('newest first') and a verification trait ('checked against its paper'). It explicitly contrasts with the sibling search_papers, so an agent can route correctly without opening the schema.

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

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

Opens with an explicit trigger ('Use this when the user wants a readable round-up of recent findings') and gives three concrete scenarios (this week in aging, notable results in a field, journal club list). It also names the alternative and the condition that selects it: 'For every paper on a question, use search_papers.'

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 readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds ordering semantics ('newest registry update first') and the returned field set (phase, status, sponsor, size, conditions, interventions, latest change), which the agent cannot infer from annotations. It stops short of describing pagination behavior beyond the cursor parameter itself.

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, both front-loaded: the trigger and scope come first, then the sort order and result fields, then the handoff to get_trial. Every clause earns its place by mapping to a filter or a returned 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?

With no output schema, the description compensates by naming what each result contains, and the sort order is stated. All nine parameters, including the relevance floor and cursor paging contract, are documented in the schema, so nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, and the description meaningfully raises it by mapping user intents to filters: 'what changed lately' points to since, 'which trials test a drug' to q/intervention, and 'which companies run them' to industry. It does not add syntax or format detail beyond what the schema already documents.

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

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

States a specific verb (list) and resource (clinical trials) with an explicit scope constraint: trials bearing on human aging or age-related conditions. It also names the read-one sibling (get_trial), so an agent can distinguish listing from fetching without opening either schema.

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

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

Opens with an explicit trigger ('Use this when the user asks about...') and enumerates the question shapes it serves: recruiting, recent changes, drug-testing, company sponsors. It closes by routing single-record lookups to get_trial, giving a concrete alternative and the condition that selects it.

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?

Goes well past the annotations (which already declare read-only, idempotent, closed-world). It discloses ranking ('best match first'), the default aging-only filter, the relaxed-match fallback when fewer than 3 results ('relaxed: true'), and an important coverage caveat that absence of a match does not mean no study exists. That last disclosure is exactly the kind of thing an agent needs to avoid overclaiming.

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

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

Front-loaded with purpose and usage before mechanics, and nearly every sentence carries distinct information. The lengthy enumeration of topic areas ('senolytics, epigenetic clocks, partial reprogramming...') is the one place it verges on bloat, though it doubles as query-expansion guidance.

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 12-parameter search tool with no output schema, it covers purpose, query syntax, ranking, default filtering, relaxation behavior, coverage limits, and the follow-up tool. The main remaining gap is that it never characterizes the result shape or pagination beyond pointing at filters, though the cursor parameter is documented in the schema.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value on the one required parameter: pass 2–4 key terms rather than the question, with a concrete good/bad example, plus the supported quoted-phrase/OR/exclusion syntax. The remaining eleven filters are only alluded to as 'the filters below', so it does not fully compensate there, but the highest-risk parameter is well covered.

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?

Opens with a specific verb and resource ('find the papers themselves') and immediately scopes it to titles/abstracts of papers AgingResearch.News has read. It is clearly differentiated from siblings: list_papers (browse), get_paper (read one in full), find_entities (entities, not papers).

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

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

Explicit when-to-use triggers (which studies exist, what papers say on a subject, with a long list of topic examples including cases where the word 'aging' is absent), explicit when-not (personal medical advice, symptoms, product recommendations), and an explicit next step ('Read one in full with get_paper'). Nothing is left to inference.

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

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

Adds substantial context the annotations cannot carry: it is asynchronous ('returns at once with the conversation's address and a question_id'), slow ('writes over several minutes'), and metered ('counts against the user's Ultradeep reviews'). It also outlines the five-section output, so the agent knows what will be produced and how to retrieve it.

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

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

Front-loads the trigger condition and keeps every subsequent sentence informative (exclusion, cost, latency, return shape). The five-section enumeration is a bit dense but each item conveys real output structure rather than filler.

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

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

There is no output schema, and the description compensates by explaining the immediate return value (conversation id plus question_id) and pointing to get_ask_answer for the result. With cost, latency, and exclusions all covered, an agent has everything needed to decide and call correctly.

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

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

Schema coverage is 100%, so question, language behavior, and conversation_id are already fully documented in the schema. The description adds no syntax or format detail about either parameter, so it sits at 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 and resource ('full review of the evidence on a research question in aging or longevity') and scopes it against a shorter answer, which is enough to separate it from ask_arn and the list/search siblings. The verb-noun pairing 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?

Gives an explicit trigger ('when the user asks for a full review... beyond a short answer') and an explicit exclusion ('Not for personal medical advice, doses or symptoms'). It stops short of naming ask_arn as the fallback for a short answer, leaving that alternative 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?

Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=true, so the agent knows this mutates follow state and is repeat-safe. The description adds no behavioral context beyond that — nothing about whether an unfollow of a non-followed entity errors or is a silent no-op, and no confirmation guidance. Adequate but additive value is low.

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. The trigger condition is front-loaded and the parameter provenance follows 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 two-parameter mutation with full schema coverage and annotations covering safety and idempotency, the description gives an agent everything needed to select and invoke it. The only gap is the absence of any note on what a successful unfollow returns or how a non-followed entity is handled.

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 schema already defines both parameters and the type enum. The description still adds real value by stating where the type/key pair comes from (list_follows, find_entities, get_entity), which is provenance the schema does not provide.

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 ('stop following an entity') and pins the domain (AgingResearch.News), so it cannot be confused with follow, list_follows, or get_entity. The wording also implicitly corrects the title's narrower 'topic' to 'entity'.

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

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

Explicitly says 'Use this when the user asks to stop following an entity,' giving a clear trigger condition and pointing at list_follows/find_entities/get_entity as the source of valid identifiers. It stops short of naming when-not-to-use cases (e.g., removing a follow that doesn't exist) or the sibling follow tool.

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