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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the tool is read-only, whether it computes results on demand or reads cached aggregates, whether a specific run state is required, or any cost/rate considerations — only what is analyzed.

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

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

A single front-loaded sentence with no filler; the analytical scope is stated immediately. It is efficient, though the brevity is partly the cause of the missing guidance rather than purely a virtue.

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

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

An output schema exists, so return values need not be described. However, with no annotations and no parameter documentation, the definition leaves an agent unable to determine prerequisites (e.g., a completed run) or how to supply run_id/need_id 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?

Both parameters (run_id, need_id) have 0% schema description coverage and are never mentioned in the description, so an agent gets no explanation of their format, source, or constraints. With two undocumented parameters this is a real gap rather than the 4 baseline for zero-parameter tools.

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 (analyze) and a precise scope (temporal persistence and monthly trajectory of evidence for a need cluster), which distinguishes it from retrieval siblings like get_evidence or comparison siblings like compare_evidence. It does not name any alternative tool, but the resource and scope are unambiguous.

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

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

There is no statement of when to reach for this tool versus get_evidence, compare_evidence, or get_coverage, nor any prerequisites such as requiring a completed run or an existing need cluster. Usage can only be inferred from the phrase 'temporal persistence and monthly trajectory'.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether submissions are idempotent, whether they overwrite prior classifications, what permissions or run state are required, or what happens on an invalid run_id – significant omissions for a mutating submit tool.

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

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

A single front-loaded sentence with no padding. It is efficient, though its brevity comes at the cost of the detail needed elsewhere.

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

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

An output schema exists, so return values need not be described. However, for a 5-parameter, 0%-coverage mutating tool with no annotations and multiple look-alike siblings, the description is not complete enough for an agent to call it 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?

Schema description coverage is 0% across five parameters, so the schema alone leaves run_id, document_id, is_relevant, reasoning, and relevance_score (which has a default) undocumented. The description gestures at document and relevance conceptually but maps to no parameter and explains none of the required/optional distinctions.

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 verb ('Submit') and resource ('relevance classification for an ingested document') are specific, and it names the research-objective context. It is reasonably distinguishable from siblings like submit_relevance_extraction_batch and submit_extracted_signals, though it does not explicitly differentiate itself from them.

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 used to record a relevance decision for a document, but gives no explicit when-to-use, when-not-to-use, or alternative guidance. With close siblings like submit_relevance_extraction_batch and submit_extracted_signals, the absence of routing guidance is a real gap.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the collection action and does not say whether the operation is read-only, what permissions are required, how 'related' is determined, or any rate limits or 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?

The description is a single front-loaded sentence with no filler or repetition. Every word contributes to stating the action and its 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?

An output schema exists, so return values need not be explained. However, with no annotations, two required parameters with no schema descriptions, and many overlapping siblings, the description is too thin to fully equip an agent to 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 0%, so the description must compensate, but it adds almost no semantic detail. It implies 'source' must be a supported source and 'document_id' refers to a document, but gives no format, allowed values, or examples for either parameter.

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

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

The description states a clear verb (Collect) and resource (related discussions or replies) scoped to a document and supported source. It does not differentiate from the sibling collect_thread, which likely overlaps in purpose, so it stops short of a 5.

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

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

There is no when-to-use guidance, no exclusions, and no named alternative. The phrase 'from a supported source' implies a prerequisite but does not tell the agent when this tool should be chosen over collect_thread or search_source.

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 usefully discloses that the tool reaches an external source and reconstructs a tree structure (root, replies, quotes), implying a network fetch and aggregated result. However it says nothing about auth requirements, rate limits, failure behavior, or whether collection is idempotent or creates stored data.

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 tight sentence with the core action front-loaded and the scope parenthetical earning its place. No 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?

The tool is simple (2 params) and an output schema exists, so return values need not be explained. Still, given zero schema coverage and no annotations, the description leaves both parameter meaning and invocation context underspecified for an agent to call it 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?

Schema description coverage is 0% and neither parameter is described beyond its title. The description hints at 'external source' (corresponding to source) but never explains valid source values or the expected thread_id format, so it fails to compensate for the coverage 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?

States a specific verb ('Fetch and reconstruct') and resource ('entire conversation thread tree') with scope detail (root post, replies, quotes) and the external-source qualifier. It is clear on its own, but the description never distinguishes it from the sibling inspect_thread, so an agent must infer the boundary.

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

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

There is no explicit when-to-use guidance and no mention of the near-identical sibling inspect_thread. The 'external source' phrase implies a context but does not say when this collection step should be preferred over inspection or search tools.

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

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

With no annotations, the description carries the full behavioral burden. It says nothing about whether this is a read-only analysis, what the run_id scoping means, whether the call is expensive or rate-limited, or what happens if an audience ID is invalid. Only the comparison facets 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?

A single, tight sentence with the verb and resource front-loaded and no filler. It is efficient, though the brevity is partly the source of the gaps elsewhere.

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

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

An output schema exists, so return values needn't be explained, but the required run_id parameter is completely undocumented anywhere and there is no guidance on obtaining audience IDs. For a two-required-parameter analytical tool with zero annotation coverage, the description leaves too much unresolved.

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

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

Schema description coverage is 0% for both parameters. The description hints that audience_ids holds two or more segments, but says nothing about run_id — an unexplained required string whose origin is left unstated. The description does not compensate for the coverage 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?

States a specific verb (compare) and resource (audience segments) and names the comparison dimensions (workflows, toolchains, pains). This distinguishes it from the other compare_* siblings like compare_needs, compare_evidence, and compare_sources by resource. It stops short of a 5 only because it doesn't explicitly route against the closest alternative (find_audiences).

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 phrase 'two or more' implies a minimum input count, but there is no when-to-use guidance, no prerequisites, and no named alternative for retrieving audience IDs first. An agent gets no help deciding between this and find_audiences or compare_needs.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing: it does not state whether comparison is costly, requires spans from the same run, or how discrepancies are represented. The output schema covers return values, but no operational context is offered.

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

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

A single efficient sentence with the purpose front-loaded and no filler. It is appropriately sized, though slight under-specification rather than tightness is the limiting factor.

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

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

An output schema exists so return values need not be described, and the tool is structurally simple with two required params. Still, the meaning of run_id and the relationship between run and spans go unexplained, and with no annotations the definition leaves real gaps for an agent to infer.

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 and it does not. 'Multiple evidence spans' hints that span_ids takes a list, but run_id is entirely unexplained (why is a run needed to compare spans?), leaving both required parameters semantically opaque.

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

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

The description gives a specific verb ('Compare') and resource ('evidence spans') plus a scope qualifier ('multiple... side by side') and a goal ('evaluate agreement or discrepancies'). It does not, however, distinguish this from siblings like verify_claims or find_counterevidence, which occupy overlapping semantic territory.

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 verify_claims, find_counterevidence, or get_evidence. The 'evaluate agreement or discrepancies' phrasing implies a comparison scenario but names no condition or alternative.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses what is being compared across each need, but says nothing about cost, permissions, run_id scoping, ordering, or limits on the number of need_ids. It leaves key operational traits undocumented.

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 tight sentence that front-loads the verb and resource and packs the comparison dimensions without any filler. Nothing is wasted.

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 means return values need not be explained, and the dimension list is helpful. But with zero annotation coverage and 0% parameter documentation, the definition under-specifies run_id handling and invocation constraints for a two-required-parameter tool.

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

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

Schema description coverage is 0% for two required parameters, so the description must compensate and it does not: run_id is never mentioned, and need_ids is only obliquely implied by 'multiple need clusters'. An agent gets no guidance on the run context or the ID list format.

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 (compare) and resource (need clusters), and enumerates the comparison dimensions: prevalence, intensity, workaround burden, cross-source convergence. It implicitly distinguishes itself from inspect_need (single need) via 'multiple', but never names a sibling, so it falls short of the 5 bar.

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?

'Multiple need clusters' implies this is for comparing two or more needs rather than inspecting one, which is a weak usage signal. There is no explicit when-to-use, when-not-to-use, or naming of alternatives like inspect_need for single needs or compare_evidence for a different resource type.

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 'compare' at least implies a non-mutating read operation. However, it says nothing about whether the run must have completed collection, whether missing sources are skipped, or any cost/latency behavior, so key behavioral context is absent.

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 that names the action, the metrics, and the scope with zero 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?

The tool is low-complexity (one required parameter, read-only aggregation) and an output schema exists, so return values need not be described. The description adequately covers what is compared; only preconditions about the run's state are 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?

There is a single parameter (run_id) with 0% schema description coverage, so the description must compensate. 'Across sources for a research run' gives the parameter meaning by identifying it as the run whose sources are compared, but adds no format or validity 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?

States a specific verb (compare) plus the exact dimensions compared (document volume, author count, cost breakdown) and the scope (across sources for a research run). This enumeration also distinguishes it from sibling comparison tools like compare_evidence, compare_audiences, and compare_needs.

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 phrase 'for a research run' implies context but there is no explicit when-to-use guidance, no prerequisites, and no routing to or away from sibling compare_* tools. An agent must infer the scenario on its own.

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 states it is a creation operation and that it returns a run ID and brief metadata, but does not disclose cost/budget implications of max_budget_usd and max_iterations, permissions required, or whether creation immediately starts a run.

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, no filler, with the action front-loaded and the return value stated second. Efficient, though the second sentence covers return data that the output schema already handles.

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 10-parameter creation tool with a budget/iteration surface and no annotations, the description is thin. The output schema covers the return value, but the behavioral and parameter context an agent needs to invoke this correctly is largely absent.

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% across 10 parameters, and the description mentions only the generic notions of brief/scope/objectives. It never explains what products, competitors, source_scope, market_domain, max_documents, seed_problems, max_budget_usd, max_iterations, or seed_audiences actually mean or accept.

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

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

The description gives a specific verb+resource (create a market research initiative) and enumerates what the brief carries (research brief, scope, objectives). It is clearly distinct from mutating siblings like update_research_brief or step_research, though it doesn't name them.

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

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

There is no explicit when/when-not guidance and no alternative is named. The agent must infer that this is the entry point that precedes step_research, get_research_state, etc., purely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a safe read ('Search') but says nothing about external network calls, rate limits, permissions, result caching, or whether results are deduplicated or ranked. For a discovery/aggregation tool this is a meaningful gap.

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

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

A single efficient sentence with the verb and resource front-loaded and no filler. Nothing needs trimming and the core scope is immediately visible.

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 search-style tool with an output schema (so return values need not be explained) and no annotations, the description covers the 'what' adequately. It falls short on workflow placement and parameter meaning, making it minimum-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?

Schema description coverage is 0%, so the description must compensate. It hints that 'query' is an audience or domain and that 'source' may take values like subreddit, GitHub repo, or forum, but never states this explicitly and says nothing at all about the 'limit' parameter or any accepted value formats.

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

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

The description gives a specific verb ('Search') and a concrete resource set (communities, subreddits, GitHub repos, forums), scoped to an audience or domain. It is distinguishable from siblings like find_audiences and discover_competitors by resource type, though it never names an alternative to route against.

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

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

There is no when-to-use or when-not-to-use guidance. The description does not say whether this should run before or after find_audiences, discover_competitors, or search_source, leaving the agent to infer placement in the research workflow entirely on its own.

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

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

With no annotations, the description carries the full behavioral burden. It states only the discovery purpose and does not disclose whether the operation is read-only, what permissions are required, how results are scoped, or what side effects exist. The output schema may cover return values, but the operational profile remains opaque.

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 wasted words. It is efficient for the purpose it states, though it does not attempt to cover the missing parameter and behavioral 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?

The output schema exists, so return values need not be explained. However, with no annotations, 0% schema description coverage, and two required parameters, the description is too thin: it omits parameter meaning, read/write behavior, and any routing guidance against closely related sibling tools.

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

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

Schema description coverage is 0% and the description does not mention run_id or product_or_domain at all. An agent learns nothing about what run_id refers to, what format product_or_domain expects, or how either parameter influences the result.

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 (Discover) and resource (competing products, alternative services, adjacent solutions) scoped to corpus signals. It is clearly distinct from most siblings, though it does not explicitly contrast with close alternatives like find_products or find_workarounds.

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

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

No when-to-use guidance, no prerequisites, and no alternative tools are named. The phrase 'mentioned in corpus signals' gives minimal context, but an agent still has to infer when this tool should be chosen over siblings such as find_products or find_workarounds.

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 supplied, so the description carries the full behavioral burden. 'Add' implies a mutation to a graph, but it does not disclose permissions required, idempotency, duplicate handling, or what mutation side effects occur. The downstream-effect sentence is useful but insufficient for a zero-annotation mutation tool.

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

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

A single efficient sentence with the core action front-loaded and no filler. It is appropriately sized, though brevity here reflects under-specification as much as discipline.

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

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

An output schema exists, so return values need not be explained. However, with no annotations, no parameter documentation, and only one sentence of guidance, the definition is too thin for a 3-required-param mutation tool that alters a search graph.

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?

All three parameters (run_id, concept, category) have 0% schema description coverage, and the description only loosely gestures at 'concept' via 'emerging concept or alias'. It never explains run_id scoping or what category values mean, so it fails to compensate for the coverage 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 states a specific verb ('Add') and resource ('an emerging concept or alias to the Query Lattice graph') with a stated purpose ('expand downstream search combinations'). It clearly conveys intent, though it does not differentiate itself from the sibling expand_concepts_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?

Usage is only implied by the phrases 'emerging concept or alias' and 'expand downstream search combinations', which hint at when this fits into a research flow. No explicit when-to-use, prerequisites, or reference to the sibling expand_concepts_batch is provided.

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

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

With no annotations, the description carries the full burden and does so well: it discloses per-item independent success/failure, idempotent retry semantics, and that canonical_concept collapses aliases while preserving aliases and provenance. The undefined limit behind 'bounded' is the only notable gap.

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

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

Three tight sentences, each covering a distinct aspect (what it adds, canonical_concept behavior, failure/retry semantics), with the core action front-loaded. No 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?

An output schema exists, so return values need not be described, and the description covers idempotency and per-item failure well. It is still incomplete on routing (batch vs singular sibling), the meaning of run_id, and what 'bounded' actually limits.

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% and neither required parameter is documented in the schema. The description meaningfully explains canonical_concept (an optional field not even named in the schema) and its effect on aliases/provenance, but leaves run_id and the structure of the concepts array entirely unexplained.

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 (add) and resource (a bounded batch of concept expansions), which distinguishes it reasonably from non-batch siblings. However, it never explicitly contrasts with the singular `expand_concepts` sibling, and the term 'host-agent concept expansions' is jargon that is not defined.

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 when-to-use guidance, no exclusions, and no comparison to `expand_concepts` or any other sibling. The only operational hint is 'can be retried idempotently,' which is behavioral rather than a selection rule.

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 disclose meaningful behavior: it writes five named files, explicitly avoids fetching/reconstructing external source content, and states that historical exports do not touch runs/latest unless set_latest=true. It omits overwrite behavior, destination path, and auth/rate considerations, so it is strong but not complete.

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, front-loaded with the core action and artifact list, followed by the non-fetching constraint and the set_latest caveat. No 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?

An output schema exists, so return values need not be explained, and the description already names the artifacts produced. The main remaining gap is where the export is written and whether existing exports are overwritten, which is relevant for a file-writing tool with no annotations.

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 gives clear semantics for set_latest (mutates latest only when explicitly true) and implies run_id scoping via 'run-scoped', though run_id's format/expected value is left undocumented.

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

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

States a specific verb (export) and resource (deterministic, run-scoped evidence pack from persisted engine data), then enumerates exactly which artifacts are produced. An agent can distinguish this from sibling tools like get_evidence or get_research_state 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?

Implies when the tool is relevant (exporting a run's evidence pack) and clarifies the set_latest condition, but names no alternative tools and gives no explicit when-not guidance, so routing relative to siblings 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?

With no annotations, the description carries full behavioral burden. 'List' implies read-only and 'discovered' hints results derive from a prior run, but there is no mention of run scoping, pagination via limit (default 20), result ordering, or what happens if the run has no audiences.

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 tight sentence with the resource front-loaded and no filler. Efficient, though at the cost of omitting needed detail elsewhere.

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

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

An output schema exists so return values needn't be described, but the definition omits run_id semantics, pagination behavior, and any usage context for a tool that must be distinguished from many find_* and compare_* siblings.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate but does not: run_id's role (which extraction run's results to list) and limit's pagination behavior are unexplained. Only the resource being listed is conveyed.

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 (functional audience segments), including what the segments contain (observed workflows and toolchains). It is distinguishable from signal/need siblings, though it does not name or contrast with the closest relative, compare_audiences.

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 indication of when to call this versus siblings like compare_audiences, find_signals, or find_needs, and no stated prerequisites despite run_id being required. The agent must infer usage entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It never states whether this is a read-only search, how results are ranked or capped, whether results persist, or any rate/pagination behavior. For a search tool in a dense toolset, this is a notable gap.

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

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

One front-loaded sentence with no filler; the resource and its operational meaning come first. It is efficient, though slightly terse for the amount of ambiguity left unresolved.

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

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

An output schema exists so return values need no explanation, but with zero parameter documentation and no annotations, the definition leaves core mechanics (run scoping, id semantics, read-only nature) unspecified. It is under-specified for a tool with two required identifiers.

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 and does not. The wording 'claim or need' loosely hints at claim_or_need_id, but run_id is entirely unexplained and neither parameter's expected format or scoping (per-run vs global) is clarified.

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 clear verb+resource (search for counterevidence) and adds a useful gloss defining counterevidence as refutations, counter-evidence, or satisfied users that weaken a claim/need. It doesn't distinguish itself from closely related siblings like get_counterevidence_candidates or verify_claims, so it stops short of a 5.

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

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

The phrase 'weaken a claim or need' implies the situation, but there is no explicit when-to-use, no exclusions, and no routing to alternatives such as get_counterevidence_candidates or compare_evidence. The agent must infer the workflow entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'List all' implies a read-only, non-destructive enumeration, but there is no disclosure of pagination behavior (despite a limit parameter), ordering, or whether the listing is scoped to a run. With zero annotation coverage, this is a notable gap.

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

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

A single front-loaded sentence with no filler that efficiently enumerates what the tool returns. It is well-sized, though the terseness contributes to the missing parameter and usage 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?

An output schema exists, so return values need not be explained, but the required run_id and the limit parameter are undocumented in both schema and description, and there is no usage framing relative to the many sibling find_* tools. Incomplete 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%, so the description must compensate and does not. It never mentions run_id (required) or limit (default 20), leaving both parameters' meaning and the pagination semantics entirely undocumented.

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 clear verb+resource: 'List all discovered need clusters', and specifies the returned fields (raw dimensions, unique authors, cross-source counts). It is distinguishable from singular siblings like inspect_need and comparative siblings like compare_needs, though it does not name them explicitly.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as find_signals or compare_needs. The agent must infer that this is the entry point for enumerating need clusters before inspecting or comparing them.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: it does not state read-only nature, ordering, pagination behavior of 'limit', whether results are run-scoped, or what happens for an incomplete run. Only the vague phrase 'extracted across evidence' hints at the data source.

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

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

A single efficient sentence with the resource front-loaded and no filler. Brevity is good, though it borders on under-specification given the tool's missing behavioral and parameter 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?

An output schema exists, so return values need not be described, and the tool has only two parameters. However, with no annotations and zero parameter documentation, the description leaves the run-scoping model and pagination semantics unexplained, which is a meaningful gap for a run-scoped extraction query.

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

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

Schema description coverage is 0% for both parameters (run_id, limit), and the description supplies no compensating meaning. It never explains that 'run_id' scopes results to an extraction run or that 'limit' caps returned mentions, so an agent gets no help interpreting required vs optional inputs.

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

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

States a specific verb+resource: finding 'product mentions and associated complaints' extracted across evidence. It is clear what the tool returns, though it does not explicitly distinguish itself from the parallel find_needs / find_audiences / find_signals family, which follow the same naming pattern.

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

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

No guidance on when to use this versus the many sibling find_* retrieval tools, nor any prerequisites (e.g. that a completed extraction run is required). The reader must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state whether this is read-only, how results are paginated or limited, what permissions the run must have, or what happens if the run_id doesn't exist.

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

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

A single tight sentence with the resource and filters front-loaded and no filler. It's appropriately sized, though brevity here comes at the cost of completeness.

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

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

An output schema exists so return values need not be explained, but with 0% schema coverage and no enum on signal_type, the agent has no way to know valid signal-type values or the limit's default behavior. For a filtered query tool in a dense sibling set, this leaves meaningful gaps.

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

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

Schema description coverage is 0%, yet the description only names two of the three parameters (signal_type, run_id) and ignores 'limit' entirely. It also gives no accepted signal_type values or run_id format, leaving the agent without the syntax needed to call it correctly.

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 clear verb (Find) and a specific resource (extracted semantic signals) with scoping filters (signal type, run ID). The resource is distinguishable from sibling find_* tools like find_needs or find_audiences, though the description doesn't explicitly contrast them.

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

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

No guidance on when to use this versus the many sibling find_* tools, nor any prerequisite or exclusion. It implies usage through the filter mention but never states 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?

With no annotations provided, the description carries the full behavioral burden, and it discloses almost nothing: not that this is a read-only query, not that it is scoped to a research run, not whether results are paginated or ranked. An output schema exists, so return shape is covered, but the tool's operational behavior is undocumented.

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

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

A single front-loaded sentence with no filler, and the defining criteria for a spend signal are stated up front. Efficient, though the terseness leaves real content gaps rather than being optimally informative.

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

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

For a tool in a large sibling family with a required run_id, 0% schema coverage, and no annotations, the one-line description is not sufficient. It omits how to obtain run_id, how this differs from find_signals, and the meaning of limit, leaving the agent under-equipped to invoke 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 description coverage is 0% across two parameters (run_id, limit), and the description mentions neither. It does not explain that run_id scopes the search to a specific research run or what limit does. This is a clear case of the description failing to compensate for an uncovered 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 (find) and a specific resource (spend signals), and even defines the semantic category: willingness to pay or commercial loss. This distinguishes it from the broader find_signals sibling. However, it never explicitly names which sibling it supersedes or how it differs from find_needs/find_products, so it falls short of a 5.

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

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

There is no when-to-use guidance: no condition, no prerequisite (e.g. that a run_id must exist from create_research/step_research), and no routing to alternatives like the general find_signals. The agent must infer everything from the name and the sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what permissions are required, how results are scoped, or what the run_id represents, leaving key behavioral traits 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?

A single sentence with zero waste, front-loading the core purpose. It is appropriately sized for a tool whose structured fields should carry most operational 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?

An output schema exists, so return values need not be explained. However, for a tool with a required run_id and no annotations, the description omits usage guidance and parameter meaning, leaving the agent without enough context to invoke it correctly beyond the bare purpose.

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 mention either parameter. The required 'run_id' and optional 'limit' are left entirely unexplained, so the description adds no parameter meaning beyond the bare schema 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?

States a specific verb ('find') and resource ('switching signals'), then defines them as users abandoning or migrating away from solutions. This distinguishes it from the broader 'find_signals' sibling, though it does not explicitly name or compare against alternatives.

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

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

The description gives no indication of when to choose this tool over siblings like 'find_signals', 'find_workarounds', or 'find_counterevidence'. There are no prerequisites, exclusions, or alternative routing guidance.

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

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

With no annotations, the description carries the full disclosure burden, yet it only implies a read operation. It says nothing about run scoping, permissions, pagination, what 'recurring' means operationally, or whether the result set is bounded by run_id. The 'all'/'recurring' framing is the only behavioral hint.

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

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

A single efficient sentence with the core scope front-loaded and no filler. It is well-sized, though its brevity borders on under-specification for a tool in a 48-sibling family.

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

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

An output schema exists, so return values need not be explained, but the description omits the required run_id contract, pagination/limit behavior, and any routing relative to the dense sibling set. For a required-parameter tool in this family, more context is needed.

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

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

Schema description coverage is 0% for both parameters: run_id is required but unexplained (which run? how obtained?), and limit's default of 20 is not discussed. The description adds no meaning beyond the parameter names, leaving the agent to infer the run_id contract on its own.

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 (find) and a specific resource (recurring workarounds and informal fixes), which an agent can distinguish from sibling 'find_*' tools like find_needs or find_signals. However, it offers no explicit contrast with those siblings, so the differentiation is inferential rather than stated.

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

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

There is no when-to-use guidance, no exclusion conditions, and no reference to any of the many sibling find_*/search_* tools. The agent must guess how this fits into the research pipeline relative to find_needs, find_signals, or find_switching_signals.

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

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

With no annotations, the description carries the full burden, and it usefully discloses that the tool is non-mutating with respect to confirmed counterevidence and claim verification. It does not cover ordering guarantees, whether calls are idempotent, or what the limiting behavior is.

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 tightly written sentences, front-loaded with the core retrieval action and followed by the crucial non-mutation boundary. No padding or restatement of the tool name.

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

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

An output schema exists, so return values need no explanation, and the tool's role is clear. The gap is the entirely undocumented parameter set, which for a 4-param tool with 0% schema coverage leaves invocation details under-specified.

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% across four parameters, and the required run_id, plus claim_id, statement, and limit, are never explained. The phrase 'ranked, topically filtered' hints at the limit and statement fields but adds no real semantics for any of 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 (Retrieve) and resource (ranked, topically filtered candidate documents) with the downstream purpose (host contradiction classification). It distinguishes itself from sibling write tools by clarifying that retrieval only registers candidates, though it never names find_counterevidence or submit_counterevidence explicitly.

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

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

Usage is implied through contrast: the description says it 'never adds confirmed counterevidence or verifies a claim,' steering the agent away from submit_counterevidence and verify_claims. However, it gives no explicit when-to-use trigger or statement of preconditions such as an existing run.

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 disclosure burden, and it does not say whether this is read-only, whether it is expensive/slow, whether it mutates run state, or whether it requires prior steps. The phrase 'identifying gaps and underexplored segments' hints at output content, but since an output schema exists that information is largely redundant.

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 front-loaded sentence with no filler; the action and scope come first. It is appropriately sized for a single-parameter tool, though it is arguably too terse given the missing usage and behavioral 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?

An output schema exists so return values need not be explained, but for a tool with zero annotations and zero schema coverage the description is too thin: no usage context, no behavioral traits, no run_id format. An agent would have to guess when this is the right call versus get_saturation.

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% and the single run_id parameter has no description, so the description must compensate. It partially does by scoping the tool to 'a research run,' which maps to run_id, but gives no format, source, or validity guidance for the identifier.

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 clear verb+resource: 'Run a rigorous coverage audit for a research run.' An agent immediately knows this tool produces a coverage analysis. It does not, however, name or distinguish itself from the nearest sibling, get_saturation, which covers overlapping conceptual ground.

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

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

There is no statement of when to run a coverage audit, what prerequisite state the run must be in, or how it differs from get_saturation or verify_claims. The agent must infer usage entirely from 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read/lookup operation and mentions verification against a persisted document, but says nothing about permissions, whether verification can fail and how, or rate/scope constraints for a tool whose main output is presumably a verification verdict.

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

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

A single front-loaded sentence with no filler. It is dense but every word contributes; it could still be slightly more informative without becoming verbose.

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

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

An output schema exists, so the description need not explain return values, and the core action is stated. However, with no annotations and zero parameter documentation, the definition leaves the agent guessing about both invocation semantics and the verification behavior.

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

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

Schema description coverage is 0% for both required parameters (run_id, span_id), and the description adds no meaning for either. An agent cannot tell whether span_id is a stable identifier, a character offset, or an opaque token, which matters for correct invocation.

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

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

States a specific verb pair ('Fetch and verify') and a specific resource ('evidence span') tied to its underlying persisted document. It is distinguishable from verify_claims and compare_evidence by focusing on a single verbatim span, though it never names those siblings explicitly.

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

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

No guidance on when to use this versus verify_claims, compare_evidence, or inspect_document, all of which appear adjacent in the tool list. The closest thing to guidance is the phrase 'against its underlying persisted document,' which hints at the verification use case but states no conditions or prerequisites.

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

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

With no annotations, the description carries the full burden. It usefully discloses the batch is 'bounded', the return fields, and that the text is untrusted corpus data. It is silent, however, on whether fetching consumes/reserves the documents, ordering, idempotency, or concurrency behavior — important traits for a batch-claim 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?

Two tightly written sentences with the purpose front-loaded and the return/safety information following. No filler or redundancy.

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

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

An output schema exists, so return values need not be re-explained, and the untrusted-data warning is a good addition. But with no annotations and an undocumented required run_id, the definition leaves gaps for a tool that feeds an extraction pipeline.

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 there are two parameters. The description explains 'limit' ('Returns up to limit documents') but says nothing about the required 'run_id', leaving half the parameters undocumented in both schema and prose.

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 ('Obtain a bounded work batch of ingested documents awaiting host agent structured signal extraction') and clarifies what is returned. It is clearly distinguishable from siblings like submit_extracted_signals or retry_extraction, though it does not explicitly name an alternative.

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

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

Usage is implied by the pipeline framing ('documents awaiting host agent structured signal extraction'), suggesting the agent calls this to fetch work and then submits results. However, there is no explicit when-to-use/when-not guidance, no mention of the paired submit tool, and no stated prerequisites such as a valid run_id.

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 full behavioral burden. 'Currently tracked' and 'inspect' imply a read-only snapshot, but the description does not state whether this is a safe read, whether the graph is scoped to a run, whether results are paginated, or how large the lattice may be. For an introspection tool with zero annotation coverage this is a meaningful gap.

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

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

A single well-formed sentence with the resource front-loaded and no wasted words. Its compactness is a virtue, though it is slightly under-specified for the scope being described.

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

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

An output schema exists, so return values need not be explained. However, for a single-parameter introspection tool the description omits parameter meaning and usage context, leaving it only minimally complete.

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

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

Schema description coverage is 0% and the single parameter run_id has no title beyond 'Run Id' and no description. The description never mentions run_id or explains which run's lattice is returned, so it fails to compensate for the undocumented parameter.

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

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

States a specific verb (inspect) and resource (all nodes and relation edges in the Query Lattice concept graph), which is concrete and distinguishes it from discovery siblings like expand_concepts or discover_communities. It falls short of naming which sibling it is preferred over, so an agent must infer its place in the graph-introspection family.

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

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

The description offers no when-to-use guidance, no prerequisites, and no alternatives among the many sibling tools (get_saturation, get_coverage, expand_concepts). The agent is left to guess under what circumstances inspecting the lattice is the right call.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read-only listing and discloses that returned data includes run state and document counts, but it omits ordering, pagination behavior, and whether results are trimmed or complete. Adequate but with clear 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?

A single front-loaded sentence with no waste. The scope (all historical and ongoing) and the returned fields are stated economically.

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

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

An output schema exists, so the description need not explain return values; the mention of state and document counts is mildly redundant but harmless. For a zero-parameter read tool, this is nearly complete, though it could say more about ordering or filtering if any applies.

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?

There are zero parameters, so there is no parameter syntax to document. The baseline for a zero-parameter tool is 4, and the description does not create any confusion about inputs.

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

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

The description uses a specific verb ("List") and resource ("historical and ongoing research runs") and even previews returned fields (state and document counts). It is clear what the tool does, but it does not explicitly differentiate itself from the sibling get_research_state, which likely retrieves a single run.

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

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

There is no explicit when-to-use guidance, no mention of alternatives like get_research_state or export_run, and no exclusions. The agent can infer this is for browsing history, but the description does not route between siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only operation via 'Retrieve' but does not explicitly state that it is non-destructive, whether it requires specific permissions, what happens if the run_id is invalid, or any rate-limit or concurrency 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, well-structured sentence that front-loads the action and resource and lists the returned data without any wasted words.

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

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

An output schema exists, so the description need not explain return values, and for a simple one-parameter read tool the purpose is adequately conveyed. However, the absence of run_id semantics and usage guidance relative to sibling state tools leaves gaps that a fully complete definition would 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?

The single parameter run_id has 0% schema description coverage and is not mentioned in the description at all. The parameter name is somewhat self-evident in context, but the description adds no meaning about its expected format, source, or relationship to the research run.

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 (Retrieve) and resource (current execution state for a research run), and enumerates the returned fields. It is clear on its own, but it does not explicitly differentiate itself from sibling tools like get_research_history or step_research, which an agent might confuse for related state operations.

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

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

The description offers no when-to-use guidance, no prerequisites, and no alternatives. It only implies usage through the word 'Retrieve', leaving the agent to infer when this state getter is appropriate versus siblings such as get_research_history.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Evaluate' implies a read-only computation over a run, but the description never confirms this, nor does it disclose cost, whether it triggers computation, or what happens if the run is still in progress. It adds only the vague concept of 'marginal yield' without explaining 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?

A single tight sentence with no filler, and the core purpose is front-loaded. It is dense rather than padded, though the undefined jargon slightly reduces immediate readability.

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

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

An output schema exists, so return values need not be explained, and there is only one parameter. However, with no annotations and no explanation of the stopping criteria or marginal-yield methodology, an agent cannot tell what trigger conditions make this call appropriate.

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 schema does not document run_id. The description implies operation on 'a run', which maps reasonably onto the single required run_id parameter, but it adds no format, provenance, or lookup detail beyond that implication.

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 ('Evaluate') and a specific subject (marginal yield and saturation stopping criteria for a run), which an agent can distinguish from siblings like get_coverage or get_research_state. The phrasing is dense and jargon-heavy, but the resource and function are identifiable.

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

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

There is no guidance on when to call this versus get_coverage, get_research_state, or step_research, all of which live in the same research-lifecycle neighborhood. No prerequisites, no exclusions, no timing cues about when saturation checking matters.

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 burden. It does disclose the categories of information returned (capabilities, pagination semantics, rate limits), which hints at a read-only inspection tool, but it never states that it is non-mutating, what permissions are needed, or whether the 'source' must already be 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?

A single front-loaded sentence that names the resource first and enumerates contents; no filler. It is efficient but lacks the routing detail that would make it fully structured.

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

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

An output schema exists, so return values need no explanation, and the description covers what is returned. However, with one undocumented parameter and no annotations, an agent still lacks the information needed to supply the 'source' argument 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?

Schema description coverage is 0% for the single 'source' parameter. The description implies the argument identifies a specific source connector but gives no format, ID scheme, or examples, so the schema's bare string remains unexplained.

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 ('Inspect') and resource ('capabilities... of a specific source connector'), with useful scope on what is inspected (capabilities, pagination semantics, rate limits). It is clearly distinguishable from siblings like get_source_status or search_source, though it does not explicitly name them.

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

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

No guidance on when to reach for this tool versus get_source_status or search_source, and no prerequisites or exclusions. The agent must infer usage from the resource name alone.

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

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

With no annotations provided, the description carries the full burden. It usefully discloses that the output is 'real-time' and covers all 12 connectors, and that configured credentials are exposed, but says nothing about authentication requirements, whether the call incurs cost, or the latency of polling live connectors.

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 well-formed sentence that front-loads the verb and resource and then lists scope. No filler or redundancy; every clause carries information.

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

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

An output schema exists, so the description need not explain return values, and the zero-parameter surface is small. It covers scope (all 12 connectors) and nature (real-time) adequately, though a hint about the relationship to get_source_capabilities would complete 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?

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond what the empty schema already communicates.

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 ('Get') plus a clearly scoped resource (source connector status) and enumerates four concrete outputs: operational status, credentials, rate limits, and costs. This makes the tool's purpose distinct in content from the similarly named 'get_source_capabilities', though it does not name that sibling explicitly.

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

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

The description states what the tool returns but gives no guidance on when to call it, when not to, or how it differs from adjacent tools like get_source_capabilities or compare_sources. An agent must infer the trigger condition entirely.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the data categories returned and implies a read-only inspection, but says nothing about permissions, failure behavior for unknown IDs, response size/truncation, or rate limits.

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 that names the action, the target, and the returned data with no filler. Every clause earns its place.

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

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

An output schema exists, so return-value shape need not be explained, and the description still helpfully previews the facets. However, for a two-required-parameter tool with zero schema coverage and no annotations, the unexplained run_id and absent error/permission context leave real gaps.

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

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

Schema description coverage is 0% for two required parameters. The phrase 'by ID' loosely maps to document_id, but run_id is never mentioned or explained in the description, leaving the agent to guess its meaning and whether it scopes the document lookup.

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 (inspect) and resource (a single indexed document) and enumerates the facets returned: full text, metadata, engagement, provenance. It implicitly separates itself from search_documents/search_semantic by being ID-scoped and singular, but it never names an alternative outright.

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

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

There is no when-to-use or when-not-to-use guidance, and no mention of prerequisites beyond needing an ID. The agent must infer that IDs come from a prior search step and that this is the follow-up deep-dive call rather than a search.

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 usefully signals a read-style drill-down that returns exact evidence spans and contradictory evidence, but says nothing about whether it is read-only, what happens with an unknown need_id, or how large the returned cluster can be. With no annotations and only partial disclosure, this sits at the minimum-viable 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?

A single front-loaded sentence with no filler; the verb and the returned artifacts come first. Nothing in it is redundant or padding.

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 exists, so return values need not be restated, and the description's enumeration of outputs is roughly sufficient. However, for a two-parameter lookup tool the total absence of parameter explanation and of any routing guidance leaves meaningful gaps.

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

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

Schema description coverage is 0% for both required parameters, so nothing in the schema explains run_id or need_id. The description does not compensate at all, leaving the agent to guess that run_id scopes a research run and need_id selects a cluster within it.

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

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

Uses a specific verb (Inspect) with a specific resource (a complete need cluster) and enumerates what it surfaces: evidence spans, metrics, contradictory evidence. This distinguishes it reasonably from find_needs (discovery) and compare_needs (comparison), though it never names those siblings to make the boundary explicit.

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

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

There is no statement of when to reach for this tool versus alternatives such as find_needs, get_evidence, or compare_needs. The agent must infer that this is a post-discovery deep-dive keyed on a run_id and need_id, and that inference is not supported by any text in the description.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Inspect' implies a read-only lookup and the phrase 'complete message tree' hints at the return shape, but there is no statement about side effects, permissions, or what 'reconstructed' means operationally.

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

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

A single front-loaded sentence with no wasted words. It is perhaps too terse for the scope it claims ('complete message tree'), but structurally efficient.

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

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

An output schema exists, so return values need not be explained, and the tool is a simple single-parameter read. However, with no annotations and no when-to-use guidance against a large sibling set, the definition is only minimally sufficient.

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% and the single parameter has no schema description, but the phrase 'by thread ID' tells the agent what thread_id identifies, partially compensating. It adds meaning but no format or sourcing detail beyond the 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?

States a specific verb ('Inspect') and resource ('reconstructed conversation thread and its complete message tree') scoped by thread ID. Clear on its own, but it does not distinguish itself from nearby siblings such as collect_thread or inspect_document, so an agent must infer the boundary.

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

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

There is no guidance on when to use this tool versus alternatives like collect_thread (which likely also deals with threads) or the other inspect_* tools. The agent is left to infer usage from the name alone.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: per-claim success or retryable failure, and isolation so failed claims do not affect successful siblings. It does not cover permissions, idempotency, or batch-size limits, but partial-failure semantics are the key trait for a batch mutation and are stated explicitly.

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 tight sentences, front-loaded with the action and precondition. The trailing clause about the legacy verify_claims tool is mildly tangential but does carry routing information, so it mostly earns its place.

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

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

An output schema exists, so return-value detail is not required, and the partial-failure behavior is covered. But with 0% parameter coverage and no annotations, the missing batch-size bound, failure-retry path (a retry_extraction sibling exists), and run_id semantics leave real gaps for a batch mutation tool.

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

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

Schema description coverage is 0% for two required parameters, so the schema adds no meaning for run_id or claim_ids, and the description does not explain either. 'Bounded batch' hints that claim_ids has a size limit but never states the bound, so it fails to compensate for the coverage 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?

States a specific verb and resource ('resolve a bounded batch of persisted claims') plus the precondition ('after counterevidence review'), which separates it from the sibling verify_claims. It is not tautological and an agent can tell what the tool does, though 'resolve' itself is left somewhat abstract.

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 phrase 'after counterevidence review' gives an implied ordering precondition, and verify_claims is named as an alternative. However, it only says verify_claims 'remains available' rather than stating when to pick one over the other, so the routing guidance is weak.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the key mutation: the document is moved back into the pending extraction queue, and only documents in the rejected/retryable-failed state qualify. It omits permission requirements, whether re-running consumes quota, idempotency, and what becomes of the prior run_id.

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 that states the object and its resulting state with no wasted words. Nothing to trim and nothing buried.

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

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

An output schema exists, so return values need not be described. The critical remaining gap is the undocumented run_id parameter and the absence of any note on permissions or side effects for a state-mutating operation. Adequate for the action itself, thin 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?

Both required parameters (document_id, run_id) have 0% schema description coverage, so the schema supplies only titles. The description mentions the document conceptually but never explains run_id or how the two identifiers interact. With low coverage the description was expected to compensate and does not.

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 effect (return a rejected/retryable-failed document to the pending extraction queue), which clearly distinguishes it from submission siblings like submit_extracted_signals or read siblings like get_extraction_batch. It is not a tautology and conveys the state transition. It stops short of differentiating itself from any closely adjacent sibling, but the resource and action are 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?

The phrase 'rejected or retryable-failed document' implicitly states the precondition for using this tool, and 'Explicitly' hints this is a manual counterpart to automatic retry handling. However there is no explicit when-to-use/when-not-to or named alternative among the many extraction siblings. Usage is implied rather than specified.

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 disclosure burden. It does convey genuinely useful behavior — that ranking is BM25 lexical scoring rather than embedding similarity, and that results can be narrowed by metadata — but it says nothing about permissions, rate limits, empty-result behavior, or how the required run_id scopes the corpus.

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 well-formed sentence with the search action and its distinguishing trait front-loaded, and no filler. It is efficient, though the density means a second short sentence about run_id scoping would have been worth the space.

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

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

An output schema exists, so return values need not be explained. However, with 0% schema coverage and a required run_id parameter that is never mentioned, an agent lacks enough context to know why the run must be supplied or how sources filtering is expressed. Adequate but with a clear gap.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters. It only loosely gestures at 'query' (keyword search) and 'sources' (metadata filtering), and says nothing at all about the required run_id or the limit/default-10 paging parameter — a significant gap for a 4-param tool.

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

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

The description gives a specific verb (search) and resource (ingested local document corpus) plus the retrieval method (lexical BM25/keyword). Naming the algorithm implicitly separates it from search_semantic and search_source, but it never names those siblings explicitly, so the differentiation is inferential rather than stated.

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

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

Usage is implied rather than stated: 'lexical BM25/keyword search' suggests it fits exact-term matching better than a semantic sibling, and 'with metadata filtering' hints at scoped queries. There is no explicit when-to-use, when-not-to-use, or named alternative (e.g., search_semantic), which the sibling list makes an obvious omission.

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 disclosure burden, and it mostly restates the mechanism. It does not explain result ordering, how limit interacts with ranking, how run_id scopes the corpus, or whether/how sources filters narrow the search — the traits an agent would need to invoke it confidently.

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 well-formed sentence with no wasted words and the core action front-loaded. It is appropriately sized, though its brevity is a symptom of under-specification rather than disciplined concision.

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

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

An output schema exists, so return values need not be described, but for a 4-parameter search tool with 0% schema coverage, zero annotations, and many competing search siblings, the description leaves too much unspecified — parameter meaning, usage routing, and result behavior are all gaps.

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

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

Schema description coverage is 0% across 4 parameters, so the description is expected to compensate and does not. run_id, sources, limit, and query all lack any meaning beyond their names; the intent of 'run_id' in particular is entirely opaque from this text.

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 ('dense semantic vector search across the local document corpus') plus a mechanism ('pinned multilingual embeddings'), so the agent knows exactly what the tool does. It fails to differentiate from close siblings like search_documents, search_source, or find_counterevidence, which is the only thing keeping it from a 5.

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

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

There is no statement of when to use semantic search versus the many other search/retrieval siblings (search_documents, search_source, find_counterevidence). No contexts, prerequisites, or exclusions are given; the agent must infer the use case entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully warns that returned document text is UNTRUSTED DATA from third-party social platforms and must not be interpreted as agent instructions, but it does not disclose other relevant behavior such as pagination, rate limits, 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?

The description is brief and front-loads the core operation before the safety warning. Both sentences carry useful information, though the second sentence is entirely a warning rather than operational 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?

An output schema exists, so return value details are less necessary. However, with no annotations, four undocumented parameters, and no usage guidance, the description is incomplete for correct invocation: an agent cannot infer source syntax, query semantics, or pagination.

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

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

Schema description coverage is 0% for four parameters, including required 'source' and 'query'. The description adds no meaning about source format, query syntax, limit behavior, or cursor-based pagination, so it fails to compensate for the schema 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 states a specific verb and resource: 'Execute a direct search on an external source connector.' This is clearer than a tautology, but it does not differentiate the tool from sibling search or discovery tools such as search_documents, search_semantic, or find_signals.

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 about when to use this tool versus alternatives. It does not mention sibling tools, required credentials, source selection, or any scenario-specific conditions for invocation.

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

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

With no annotations, the description carries the full burden and does well: it discloses that discovery, collection, and indexing are executed, that the run pauses in 'awaiting_extraction', and that verification is gated until all claims reach a terminal disposition. It omits idempotency, error behavior, and permissions, keeping it 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 compact sentences, front-loaded with the core action followed by the state transitions. Every sentence carries meaning; no 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?

An output schema exists, so return values need not be explained. For a complex state-machine tool the state coverage is strong, though the absence of any note on idempotency or repeated invocation leaves a minor gap.

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

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

Schema coverage is 0% and the single parameter run_id is never explained in the description. The parameter name is fairly self-evident, so the gap is modest, but the description does nothing to compensate for the missing schema 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?

States a specific verb ('Advance') and resource ('the research workflow for a run'), and frames the tool as a state-machine driver. An agent can distinguish it from siblings like get_research_state or verify_claims, though it doesn't name them explicitly.

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

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

Gives clear state-conditional guidance: it explains what the tool executes depending on whether the run is in 'brief_compiled'/'expanding', 'awaiting_extraction', or 'awaiting_verification'. No explicit alternatives are named, but the branching conditions effectively tell the agent when to invoke 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?

With no annotations, the description carries the full behavioral burden, and it does disclose one important trait: only is_contradiction=true persists confirmed counterevidence. It says nothing about idempotency, required run/claim state, or what happens to candidates judged false, so coverage is 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?

Two tight sentences with the core action front-loaded and no filler. The second sentence earns its place by stating the persistence rule, though a few more words would be needed to be fully actionable.

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

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

An output schema exists so return values need no explanation, and the persistence rule is captured. But for a six-parameter mutation tool with zero schema descriptions and no annotations, the missing parameter semantics leave a meaningful gap an agent must guess at.

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 six parameters exist. The description only gestures at is_contradiction's effect; run_id, claim_id, document_id, reasoning, and confidence are left entirely unexplained in both schema and prose, so it fails to compensate for the coverage 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 gives a concrete verb ('Classify') and a bounded resource ('one retrieved candidate') with the judgment target ('confirming or not confirming a contradiction'). The word 'one' implicitly distinguishes it from the sibling submit_counterevidence_batch, though that alternative is never named.

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 trigger condition for the tool to have effect ('Only an explicit is_contradiction=true judgment adds confirmed counterevidence'), which implies when it matters. However it never names alternatives such as get_counterevidence_candidates (upstream retrieval) or submit_counterevidence_batch, so the routing guidance is only implied.

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

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

With no annotations, the description carries the full burden and does disclose useful traits: per-item persistence, idempotent duplicate retries that replace the prior claim/document judgment, and partial-failure semantics that flag retryable items. However, it omits any auth/permission requirements, batch-size limits despite calling itself 'bounded,' and rate/throughput behavior, so the disclosure is meaningful but incomplete.

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 dense sentences, front-loaded with the primary action before the behavioral detail. Nothing is wasted, though the second sentence packs several distinct behaviors (persistence, idempotency, retry signaling) into one clause chain.

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

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

An output schema exists, so return values need not be re-explained, and the retry/persistence semantics are helpful. But with a fully opaque nested 'items' array and 0% schema coverage, an agent still lacks the information needed to construct a valid request, leaving the definition only partially complete.

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

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

Schema description coverage is 0% and the 'items' parameter is an undifferentiated array of free-form objects with no documented fields, while run_id is undocumented entirely. The description mentions 'bounded' items but never explains the item shape, required keys, or run_id, so it fails to compensate for the coverage gap on the tool's central parameter.

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

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

The description states a specific verb (Submit) and resource (counterevidence classifications) and adds the scoping qualifier 'bounded batch,' which distinguishes it from the sibling submit_counterevidence. It does not name the sibling directly, but the batch framing is clear enough for an agent to tell the two apart.

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

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

There is no explicit when-to-use guidance, no condition selecting this tool over submit_counterevidence (single) or resolve_claims_batch, and no prerequisites or exclusions. Batch submission is implied only by the word 'batch' in the name and description.

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

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

With no annotations, the description carries the full burden and does disclose non-obvious behavior: the engine validates exact matching and content hashes, and need-bearing types require a type-aligned host-normalized field because raw quotes/headlines/switching statements are never promoted to canonical needs. It does not cover failure modes, idempotency, or retry behavior, which is the remaining gap.

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

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

Three dense sentences that are front-loaded with the action and payload, then validation and promotion rules. Every sentence carries substantive information with little waste, though the second half is syntactically heavy.

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

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

An output schema exists so return values need not be explained, and the promotion/validation rules are a good start. But for a tool requiring three undocumented params with a free-form nested signals payload, the description leaves the agent without enough to construct a valid submission.

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

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

Schema description coverage is 0% for all three required params, so the description must compensate. It adds meaning only for the signals payload (need-bearing type fields), leaving run_id and document_id entirely unexplained and the general shape of the signals array unclear.

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 (Submit) and resource (schema-validated market signals and verbatim evidence quotes) scoped to a persisted document. It is distinguishable from siblings like submit_counterevidence or submit_relevance_extraction_batch by the signal/quote payload, though it never explicitly names those alternatives.

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

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

The phrase 'extracted by the host agent for a persisted document' implies the calling context, but there is no explicit when-to-use guidance or statement of when to prefer this over submit_counterevidence or the various submit_*_batch siblings. Usage is implied rather than directed.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses single-read semantics, unchanged exact-span validation, explicit per-item success/failure, and idempotent retryability. These are genuinely useful behavioral traits, though it omits auth requirements and bounds/limits on batch size.

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 tightly-packed sentences that front-load the action and then the operating characteristics, with no filler. Slightly dense but every clause carries information.

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

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

Output schema exists, so return values need not be described, and the behavioral prose is solid. But for a batch submit tool with zero schema coverage and no annotations, the absence of any item-shape or run_id guidance leaves a real gap 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% for two required parameters, so the description must compensate. It never explains what run_id identifies or what the items array should contain (shape, span format, judgment fields), leaving the caller to infer everything from an opaque 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 ('Submit') and resource ('bounded batch of combined host relevance judgments and structured signal extractions'), and the 'combined' framing distinguishes it from the separate classify_document_relevance and submit_extracted_signals siblings. It stops short of naming those siblings explicitly, so it lacks full differentiation.

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

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

The phrase 'normal autonomous high-volume path' implies this is the default bulk route and contrasts with some non-normal path, giving an agent usable routing context. However, it never names an alternative or states a when-not condition, so the guidance remains implied rather than 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?

No annotations, so the description carries the full burden. It reveals a mutation but says nothing about whether updates merge or replace existing content, what happens to fields not supplied, required permissions, or reversibility — a significant gap for a write tool.

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

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

A single front-loaded sentence with no filler; the verb and target resource lead. It is efficient, though its brevity contributes to the under-specification problem rather than solving it.

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

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

An output schema exists, so return values need not be explained, but for a 6-parameter mutation tool with zero annotation coverage the behavioral and parameter detail is far too thin for an agent to call it safely.

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

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

Schema description coverage is 0% with 6 parameters. The description mentions only some fields (seed audiences, exclusions, loosely 'hypotheses') and omits products, competitors, and seed_problems, leaving most parameters semantically undocumented in both schema and prose.

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

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

Clear verb+resource: 'Update an existing research brief', and it names some of what can be changed (hypotheses, seed audiences, exclusions). It implicitly distinguishes itself from create_research via 'existing', but does not explicitly differentiate from any sibling tool.

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

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

'with newly discovered hypotheses' hints at when to reach for it, and 'existing' implies the brief must already exist. However, no alternatives (e.g. create_research) are named and no conditions for choosing this over related research-state tools are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether verification writes back claim status, mutates state, requires a completed run, or what happens when claim_ids is omitted.

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

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

A single front-loaded sentence with no filler. Efficient, though the compressed jargon limits readability slightly.

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

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

With an output schema present, return values need no explanation, but for a two-parameter verification tool with no annotations the description leaves too much unstated: mutation semantics, scope of run_id vs claim_ids, and when to prefer a sibling.

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 explains neither parameter. It never clarifies that run_id scopes the verification or that claim_ids optionally narrows to a subset (default null implies all claims, which the description should have stated).

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

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

States a concrete verb pair (validate, reconcile) and resource (research claims) with the criteria it applies (multi-source independence, counter-evidence). This differentiates it from siblings like find_counterevidence and compare_evidence, though the jargon-heavy phrasing adds some ambiguity.

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 indication of when to invoke this versus resolve_claims_batch, compare_evidence, or find_counterevidence. No prerequisites, no workflow placement, no exclusions are given.

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