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

Adds real context beyond the annotations: originals and prior exports remain unchanged, caller-chosen output paths and overwrites are rejected, output is always a new unique 16kHz mono WAV. This coheres with destructiveHint=false and idempotentHint=false and explains why repeated calls are non-idempotent, though it says nothing about failure modes or the 240s/8MiB bounds beyond what the schema already carries.

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?

Four short, front-loaded sentences with no filler; the output artifact and immutability guarantee lead. The final sentence about image_manifest_read is slightly cryptic without more context, keeping it from a 5.

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, and the annotations plus description together cover safety, idempotency and mutation scope for a single nested request object. Nothing essential to invoking it correctly appears missing.

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

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

Schema description coverage is 100%, so file_path, expected_source_sha256, start_seconds and end_seconds are already documented, including the omitted-endpoints behavior. The description's phrase 'whole or one-sided' merely restates what the schema says and adds no format or semantics for the SHA-256 requirement.

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 (whole or one-sided audio selection) plus the exact output artifact: a unique private 16kHz mono WAV. An agent can distinguish this from sibling media tools like video_clip_export or audio_transcribe immediately.

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 clarifies scope (whole selection when endpoints are omitted, one-sided otherwise) and points to image_manifest_read for a verified restart, which gives some routing value. But it never states when to prefer this over audio_transcribe, media_edit_footage, or video_clip_export, nor any prerequisite like needing a prior manifest/source ingest.

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

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

Annotations already declare the safety profile (non-destructive, non-idempotent, closed-world), and the description adds real value on top: an environment dependency (optional audio extra + local FFmpeg) and a semantic limitation ('Similarity does not establish equal speech, speaker identity or permission to delete evidence'). It does not clarify the readOnlyHint=false behavior (what, if anything, is written), leaving a minor 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 compact sentences, front-loaded with the core action before the dependency and caveat. Every sentence earns its place; no redundancy with the schema or annotations.

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

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

Output schema exists so return values needn't be described, parameters are fully covered by the schema, and annotations carry the safety profile. The description completes the picture with the environment prerequisite and the key semantic caveat, so an agent has what it needs to call it correctly.

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

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

Schema description coverage is 100% and the nested request, segments, threshold and SHA-256 fields are all documented in the schema. The description adds no syntax, format, or constraint detail beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific verb and resource ('Compare local audio candidates') and is clearly distinct from the sibling video_deduplicate_frames. However, 'candidates' and 'retaining silence, errors and uncertainty' are somewhat abstract, leaving the exact operation slightly fuzzy, and no sibling is named 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?

Provides a prerequisite ('Requires the optional audio extra and local FFmpeg') and a scope caveat, which implicitly signals when it applies. But there is no explicit when-to-use guidance or routing versus alternatives such as video_deduplicate_frames or audio_dsp_analyze.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=false, so the agent knows this is a non-read-only, non-idempotent, non-destructive, closed-world operation. The description adds behavioral context about artifact reuse ('Reusing an exact job_id reads its attested artifacts without launching again') and limitations ('Standards and semantic claims are unverified,' explicit mono derivation for Ferrous, 30-second/8MiB limits). This is useful supplemental behavior, but much of it is scattered and some claims are vague. With annotations already carrying the safety profile, a 3 reflects the added value without over-crediting.

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 dense, multi-clause paragraph with obscure terminology ('operator-pinned native DSP workflow,' 'attested artifacts,' 'finite silence/abstentions,' 'Juzzy modes'). It is not front-loaded with a simple statement of purpose, and several sentences feel like internal notes patched together rather than a crafted tool definition, making it hard for an agent to parse quickly.

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 and 100% schema description coverage exist, so return values need not be explained, and annotations cover the safety profile. However, because this is a complex tool with many modes and a nested request object, the description should more clearly explain mode selection, job_id reuse semantics, and the difference from sibling audio tools. As written it gestures at these topics without giving a complete picture, so it is just adequate.

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

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

Schema description coverage is 100%, so the schema already documents parameters like file_path, expected_source_sha256, operation enum, start/end_seconds, reference, and native_return_format. The description adds only indirect meaning: it clarifies that A/B uses reference-minus-primary, that Juzzy modes preserve certain observations, and that Ferrous receives an explicit mono derivation. These are behavioral notes rather than parameter syntax, and the operation enum contents are not explained in the description, so the baseline 3 is appropriate.

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

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

The first sentence states the tool 'measures audio or invokes one separately installed operator-pinned native DSP workflow,' which gives a verb and resource, but 'one separately installed operator-pinned native DSP workflow' is obscure jargon that doesn't tell an agent concretely what happens. The body discusses outputs and modes rather than clarifying the core operation, and it doesn't distinguish itself clearly from siblings like media_analyze_music or audio_transcribe.

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 never states when to choose this tool over alternatives such as media_analyze_music, audio_transcribe, or media_perceive. It mentions 'Use job_status for durable status,' which is a follow-up routing hint, but there is no guidance on when-not-to-use or what conditions select this tool versus its many 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?

Annotations already mark it non-read-only, non-destructive, open-world, and non-idempotent, so the safety bar is partly covered. The description adds real behavioral context beyond that: provenance rules (source cue/word times are assertions, model output is inference), the constraint that local-only forbids cloud, the readback receipt requirement, and the crucial operational fact that no local model is installed.

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?

Purpose is front-loaded and every sentence carries information with no filler. The telegraphic, clause-heavy style ('Supplied cue and word times remain source assertions') is dense and slightly cryptic, which marginally reduces 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?

Given a complex nested request object and an existing output schema, the description covers the key operational facts an agent needs (no local model, backend selection, local-only restriction, receipt-gated readback) and does not need to restate return values. It leaves the request structure itself to the schema, which is acceptable.

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

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

Schema description coverage is 100%, so the baseline would be 3. The description still adds meaning by tying concepts to fields: caption selection ordering, 'explicit backend' for ASR, local-only forbidding cloud requests, and the receipt-digest/source-identity requirement for readback, which map to backend, local_only, and expected_receipt_sha256.

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: extracting caption intervals or inferring speech from audio via an explicit backend. It is clear what the tool does, but it never names or distinguishes itself from close siblings like media_caption_events, audio_dsp_analyze, or media_perceive, so the 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?

The description gives ordering/constraint cues ('Caption selection precedes ASR; local-only selection forbids cloud requests; Readback requires the retained receipt digest') which imply when each path applies. However, it never states when to use this tool versus alternative transcription/caption siblings, so 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds real behavioral context on top: it names the underlying model (Gemini), states that structured output is used for reliable JSON, and discloses the default response schema. It does not cover failure modes, rate limits, or size limits, 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 sentences, front-loaded with the core action and the hard input constraint before the implementation detail about Gemini and output_schema. No filler, though the model-name detail is the least load-bearing sentence.

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 6-parameter, zero-required tool, the description covers the input-exclusivity rule, the default schema, and how to override it. It omits practical limits (file size, supported PDF scope, URL fetch failures) but is otherwise sufficient to call the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, and the description adds meaning the schema cannot express: the mutual-exclusion rule among file_path/url/text (all three are independently optional with null defaults in the schema). It also clarifies that output_schema overrides the default ContentResult shape, and that instruction drives what gets analyzed.

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 (analyze) and enumerates the accepted resource types (file, URL, text), which is more precise than a bare name restatement. However, it never differentiates itself from near siblings such as content_extract, content_batch_analyze, or video_analyze, 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?

The description gives one real operational rule — 'Provide exactly one of file_path, url, or text' — which is genuinely useful invocation guidance. It stops there: no when-to-use conditions, no guidance on choosing this over content_extract/content_batch_analyze, and no mention of when to supply a custom output_schema versus accepting the default.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description goes beyond them by disclosing concrete limits: rejection over 5,000 discovery entry visits, compare payloads over DOC_MAX_DOWNLOAD_BYTES, and 3-way bounded concurrency in individual mode. These operational constraints are genuinely useful and not derivable from the annotations.

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

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

Front-loads the core action, then constraints, then the two modes. Tight and readable with little waste, though the mid-sentence line break in the source text is a minor formatting blemish.

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, and the description covers the mode selection and payload limits for this 8-param tool. It is nearly complete, missing only sibling-tool disambiguation to be fully self-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 description coverage is 100%, so the schema already documents all 8 parameters, establishing a baseline of 3. The description reinforces mode semantics and adds the concurrency/limit context but supplies no syntax or format detail beyond what the schema provides.

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 (analyze) and resource (multiple content files), with the batch scope made explicit via 'multiple content files from a directory or explicit file list'. This implicitly separates it from the single-file content_analyze sibling, though it never names that sibling or video_batch_analyze to fully disambiguate.

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 solid intra-tool guidance by explaining when to pick 'compare' (cross-document, single call) versus 'individual' (per-file, bounded concurrency). However it offers no guidance on when to use this tool versus alternatives like content_analyze or video_batch_analyze, so tool-level selection is left to inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds meaningful behavioral context by stating it uses Gemini's response_json_schema for guaranteed structured output, which tells the agent the output reliability and mechanism.

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-load the core action and then add the key implementation detail. There is no filler or repetition, and the structure makes the tool's purpose immediately clear.

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 a fully described input schema and an output schema, the description does not need to explain return values or parameter formats. It provides enough context for an agent to know this is a read-only structured extraction tool, though it could mention practical limits or content-type applicability.

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

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

Schema description coverage is 100%, so both parameters are already documented in the input schema. The description does not add syntax, format, or constraint details beyond what the schema provides, making the baseline of 3 appropriate.

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

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

The description states a specific verb and resource: extract structured data from content using a JSON Schema. This clearly distinguishes it from generic content analysis or media tools, though it does not explicitly name the closest sibling alternatives like content_analyze or web_extract.

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 usage when structured extraction is needed, but it gives no explicit when-to-use, when-not-to-use, or alternative-tool guidance. An agent must infer from the presence of the required schema parameter that this is the right choice over content_analyze.

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

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

Annotations already declare the safety profile (readOnly=false, openWorld=false, destructive=false), and the description adds real context beyond them: the external FFmpeg dependency, the LOCAL_FILE_ACCESS_ROOT scoping, the hash-to-bytes binding caveat, and that large outputs retain metadata/path only. It stops short of detailing failure modes or rate 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?

Four tight sentences with the purpose front-loaded and the constraints following in priority order. The final sentence's caveat about factual support/synthetic inputs is somewhat tangential but still earns its place as a scope limiter.

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 covers prerequisites, path scoping, and caveats. It is nearly complete; only explicit sibling routing is 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 coverage is 100%, so all four parameters (crop_box, file_path, output_path, include_image) are already documented in the schema. The description adds no syntax or format detail beyond it, so baseline 3 is correct.

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

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

States a specific verb and resource ('Crop local PNG pixels') and immediately scopes it against inference-based siblings with 'without model inference or provider uploads,' so an agent can distinguish it from image_edit/image_segment 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?

The phrase 'without model inference or provider uploads' signals the deterministic-local use case, and 'Requires an independently installed FFmpeg' plus the LOCAL_FILE_ACCESS_ROOT reference give prerequisites. However, it never names an alternative tool or states when-not-to-use it, so routing still requires inference.

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

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

Annotations already declare the safety profile (readOnly=false, destructive=false, non-idempotent), so the bar is lower. The description still adds real behavioral context: the tool persists a manifest, dependency requirements (images extra, local FFmpeg for frame selection), and that source-derived edits keep explicit provenance. It does not clarify whether the original file is ever overwritten, which is the main remaining ambiguity.

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?

Every sentence carries information and the core purpose plus the manifest persistence is front-loaded. The remaining sentences are tightly packed (grid semantics, dependencies, provenance) with no filler. Slightly dense, but 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?

An output schema exists, so return-value explanation is unnecessary, and the 100% schema coverage documents all nested parameters. Given that support, the description supplies what structured data cannot: dependency requirements, coordinate-grid semantics, and provenance guarantees. An agent has enough 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 100%, so the nested crop/cutout/resize/annotation parameters are already documented, making 3 the baseline. The description adds only one semantic detail beyond the schema: coordinates are resolved on the oriented source grid before crop and resize, which clarifies ordering but not formats. It does not explain output_format/quality tradeoffs or the expected_source_sha256 guard.

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 concrete verb and resource ('Edit a source image or decoded video frame') plus the persistence side effect ('persist its exact manifest'). It clearly differs from read-only siblings like image_read or media_info. It never names or contrasts with the closest sibling, image_crop, so sibling differentiation is left to inference.

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

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

It gives prerequisites for use ('Requires the optional images extra; frame selection also requires local FFmpeg'), which is genuinely actionable. However, it offers no when-to-use/when-not guidance and never points to image_crop or media_edit_footage as alternatives for simpler cases. Usage is implied by the capability list rather than explained.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed-world scope, so the safety profile is covered. The description adds that this verifies source and artifact bytes, which is useful behavioral context, but it omits what happens on a digest mismatch (error vs. partial result) and how 'bounded' artifact inclusion behaves.

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 naming the action first, with no filler. It is efficient, though the trailing verification clause packs two distinct behaviors into one unpunctuated phrase.

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 annotations carry the safety profile. The description covers the core action and verification intent, leaving only edge-case behavior (digest mismatch, 'where bounded' artifacts) unstated.

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

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

Schema description coverage is 100%, so all three parameters (manifest_path, expected_sha256, include_image) are already documented in the schema, setting a baseline of 3. The description's 'verify its source and artifact bytes' loosely gestures at expected_sha256 and include_image but adds no format or constraint detail beyond the schema.

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

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

States a specific verb+resource (read a manifest) and adds verification of source and artifact bytes, which is more than a tautology. However, it does not differentiate itself from adjacent siblings such as image_read, media_info, or source_ingest_read, and the phrase 'exact manifest' is jargon that isn't explained.

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 clause 'after restart' implies a usage context (post-restart integrity verification), which is a weak but real hint at when to invoke it. No alternatives are named and no explicit when-not condition is given, so guidance is implied rather than stated.

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

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

Annotations already fix the safety profile (destructive=false, openWorld=false), and the description adds two real behavioral facts beyond them: OCR text and geometry do not establish table structure or factual support, and missing local runtimes yield an explicit limitation instead of a silent failure. There is mild tension between "Observe" and readOnlyHint=false, but the tool plausibly writes prepared-image artifacts, so this is not a hard contradiction.

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

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

Two short sentences, purpose front-loaded, with the limitation caveats following. Every clause carries information; nothing is padding or restated from the schema.

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

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

An output schema exists, so return values need not be described, and all parameters are documented in the schema. The description covers engine locality and failure/unreliability semantics, but omits when to prefer this over vision_ocr and does not clarify what is written given readOnlyHint=false.

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

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

Schema coverage is 100%, so the schema already documents file_path, engine, crop, resize, languages, and the rest; baseline 3 applies. The description adds only that the engine is local and explicitly chosen, a small increment over the enum values in the schema.

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

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

The description names a specific verb+resource ("Observe text and geometry") and scopes it to "an explicitly selected local OCR engine," which separates it from the sibling vision_ocr (likely the cloud path). It is clear what the tool does, though it never names the sibling it is not, so differentiation requires inference.

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

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

Usage is only implied: the caller is told the engine must be selected explicitly and is local, but there is no explicit statement of when to choose this over vision_ocr or image_read. The second sentence reads as an interpretation caveat rather than selection 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?

The description frames a purely passive read ('Return ... as inspectable PNG', 'this server invokes no model or upload'), yet readOnlyHint=false declares the operation is not read-only. An agent that trusts the description will treat this as a safe read while the annotation says state may change, which is the contradiction pattern. The genuinely useful disclosures (bounded output, one-still limitation for animated inputs, no model/upload) are undermined by this mismatch.

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 with the core purpose front-loaded and no filler; the animated-input caveat and the model/upload note are compact. It is slightly abstract in phrasing but earns its length.

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 covers purpose, the animated-input limitation, and the no-model/no-upload behavior. Only the missing sibling-routing guidance and the annotation mismatch leave a 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 100%, so file_path, max_pixels, and include_image are already fully documented. The description only echoes the bounding concept via 'bounded local still image' and adds nothing about max_pixels semantics or the include_image toggle, so the schema carries the load.

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 and resource ('Return a bounded local still image') plus the output form (inspectable PNG and exact source metadata), so the agent knows what it gets back. It does not explicitly differentiate itself from close siblings such as image_crop, image_ocr, or media_info, which keeps it below 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 description implies usage by describing behavior on animated inputs, but never states when to reach for this tool versus image_crop, image_edit, video_frame, or media_info, and gives no when-not conditions. Context is implied rather than prescribed.

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

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

Annotations only declare the generic profile (write, open-world, non-idempotent, non-destructive). The description adds substantive context the annotations cannot: outputs are 'unverified proposals', and service/checkpoint declarations 'do not attest a loaded model or establish redistribution rights' — real trust and licensing caveats for an external-service call.

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

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

Two short paragraphs with the action front-loaded and no filler sentences. The prose is dense and slightly abstract ('checkpoint declarations'), but every sentence carries distinct information.

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

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

With an output schema present, return values need not be described, and annotations cover the safety profile. The description supplies the missing behavioral caveats (unverified outputs, service/provenance limits), leaving only minor gaps such as the async/job nature of a 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 coverage is 100%, so the baseline is 3. The description goes slightly beyond it by mapping 'plan' to the dry-run path and by framing service_id as a 'service selection' whose declaration carries no model-provenance guarantee, and by tying 'preserve artifacts' to include_image.

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 pair ('plan or submit') and resource ('one image') and states the deliverable ('mask and overlay artifacts'), which identifies it as a segmentation tool. It does not, however, contrast itself against nearby siblings like image_crop, image_edit, or vision_grounding, so differentiation is left to the tool name.

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 'plan or submit' framing implies a two-phase workflow (dry_run first, then authorized submission), and the caveat that submission requires an explicit grant hints at a prerequisite. But there is no explicit statement of when to choose this over image_crop/image_edit or any exclusion criteria.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=false, so the safety profile is carried by structured data. The description adds little beyond restating the action enum and does not flag which action (clear) is the destructive one, but since annotations cover this the minimum viable 3 applies.

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

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

A single front-loaded sentence with no filler; the resource is stated before the operations. It is efficiently sized, though it leans on the enum rather than explaining intent.

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 a full output schema and complete annotations carrying the safety and return semantics, and 100% parameter coverage, the description is adequate for calling the tool. It stops short of explaining operation selection, which is the only notable gap.

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

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

Schema description coverage is 100%, so action, auth_token and content_id are already documented in the schema (including the INFRA_ADMIN_TOKEN note). The description 'Scope clear to a specific content ID' adds nothing the schema does not already state, so the baseline 3 is appropriate.

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

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

The description names a specific resource ('the analysis cache') and enumerates the four operations (stats, list, clear, inspect context), which maps cleanly to the action enum. It is distinguishable from most siblings, though it never explicitly positions itself against the nearby infra_configure 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?

Usage is only implied through the action list; there is no statement of when to choose stats vs list vs context, nor any exclusion or prerequisite guidance (e.g., that clear is the mutating path). An agent must infer operation selection from the enum 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context beyond them: the change is a live, in-process mutation that takes effect immediately and persists only for subsequent tool calls. It does not clarify scope (session vs. all users) or what happens to fields left unset, which is why it falls short of 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?

Two short sentences, zero filler, with the core action and its field set front-loaded before the side-effect note. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained, and annotations cover the mutation safety profile. The description supplies the key runtime-effect context, but a reconfiguration tool would benefit from stating whether omitted parameters leave existing settings unchanged and whether the change is scoped to the session or the whole server.

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

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

Schema description coverage is 100%, and the schema itself is richer than the description (model precedence over preset, temperature unsupported on certain Flash models, conditional auth token). The description merely lists the four configurable aspects, adding no semantics the schema does not already carry.

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

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

Specific verb ('Reconfigure') plus resource ('the server at runtime') and an enumeration of exactly what can be changed (preset, model, thinking level, temperature). No sibling in the tool list performs runtime configuration, so the tool is unambiguous even without naming 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?

There is no explicit when-to-use/when-not or comparison to an alternative, but with no sibling config tool the usage is reasonably implied. The note that changes apply to all subsequent tool calls gives context about consequences rather than guidance on choosing this tool.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=false, so the description carries the real behavioral burden, and it does so well by disclosing that cancellation is not always immediate: queued work is cancelled outright, while active work only receives a cooperative stop request honored at the next checkpoint. It stops short of covering idempotency, error behavior for unknown/finished jobs, or permission requirements.

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 immediate-cancel case is stated first and the cooperative-stop nuance second, which is the correct priority order.

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 annotations cover the safety profile. The description supplies the key operational nuance an agent needs. Minor gaps remain around what happens if the job is already finished or the ID is invalid, but the definition is broadly complete for a one-parameter cancel 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 100% and the single job_id parameter is already documented as a 'Durable video batch or window-run ID'. The description adds no format, scoping, or lookup detail beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb (cancel) and resource (queued video work / jobs), and it distinguishes two operating modes: immediate cancellation of queued work versus a cooperative stop request for running work. It does not name or differentiate itself from siblings like job_status or source_ingest_cancel, 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 explicit when-to-use or when-not-to-use statement, and no alternative tool is named. However, the description does implicitly scope usage by job state (queued vs. running) and by the fact that a running job is only asked to stop at the next checkpoint, which is meaningful routing information.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds the useful notion that results are 'retained' and that the byte count is a 'current' attestation (implying repeated polling), but says nothing about behavior when the job_id is unknown or expired.

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 payload front-loaded; nothing is wasted. It is slightly undermined by the unexplained term 'byte attestation'.

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, the description needn't enumerate return values, and the sole parameter is fully documented. However, for a status tool tied into a job lifecycle with many sibling producers, it omits when the tool is applicable and how to interpret a missing/expired job.

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

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

Schema description coverage is 100% and the single job_id parameter is documented in-schema as 'Recorded durable job ID'. The description adds no format, origin, or lookup guidance beyond that, so the baseline 3 applies.

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

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

The description gives a clear verb ('Read') and resource ('job'), plus the fields returned (identity, outcomes, byte attestation). It does not distinguish itself from the sibling job_cancel or from the ingestion tools that create jobs, and 'byte attestation' is opaque jargon, keeping it below 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 call this versus job_cancel, or when a job_id becomes available (e.g. after source_ingest or research_web). The agent must infer that this is a polling/status lookup 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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds genuinely useful behavior beyond that: the answer is synthesized rather than raw, it is grounded in stored objects, and it returns source citations, which tells the agent what to expect in the response.

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

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

Front-loaded with the core action in the first sentence and kept to two short sentences. 'Uses Weaviate AsyncQueryAgent in ask mode' is mildly implementation-flavored, but it does convey synthesis behavior, 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?

With an output schema present and annotations covering the safety profile, the description only needs to convey the synthesis/citation behavior, which it does. It omits any note about latency or async semantics despite 'AsyncQueryAgent', a minor gap for a grounded-generation 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 100%, so both the query and collections parameters are already documented in the schema. The phrase 'across knowledge collections' loosely reinforces the collections parameter's scope but adds no format or syntax detail, so the baseline 3 applies.

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

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

States a specific verb (ask a question) and resource (stored knowledge), and the phrase 'AI-generated answer' distinguishes it from retrieval siblings like knowledge_search or knowledge_query. However, it never names those siblings, so the agent must infer the distinction itself.

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

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

The description implies Q&A synthesis rather than raw retrieval, but gives no explicit when-to-use or when-not-to-use guidance against the many knowledge_* siblings. The agent has to infer that this is the synthesis path and knowledge_query/search are the lookup paths.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, covering the safety profile. The description adds only that the lookup is single-object scoped, and says nothing about behavior on a missing UUID or invalid collection. With annotations carrying the load, this is adequate but thin.

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 key qualifiers (single, by UUID, from a collection) are all present and 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?

With an output schema present and annotations covering safety semantics, the description needn't explain return values. The only real gap is the absence of any note on error/not-found behavior, which is minor for such a simple retrieval 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 100%, with object_id documented as a Weaviate UUID and collection as a fully enumerated set, so the schema does the heavy lifting. The description adds no syntax or format details beyond that, which is the expected baseline.

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

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

States a specific verb+resource+scope: 'Fetch a single object by UUID from a knowledge collection.' The 'by UUID' and 'single object' phrasing implicitly distinguishes it from search/query siblings like knowledge_search and knowledge_query, but it never names them or draws the contrast 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 only implied: 'by UUID' suggests the caller already holds the identifier and doesn't need a search. There is no explicit when-to-use, when-not, or named alternative for cases where only a name/filter is known.

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

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

Annotations already declare this is a write (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the safety profile is covered. The description adds real behavioral context beyond that: properties are validated against the collection schema and unknown keys are rejected with allowed name:type pairs — useful failure-mode disclosure. It doesn't mention duplicate handling despite idempotentHint=false.

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 plus a tip: the action is front-loaded, the validation rule follows, and the prerequisite call is last as a distinct actionable note. 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 no explanation, and the write/validation semantics are covered. For a mutation tool with idempotentHint=false, the only notable omission is whether re-inserting the same data creates duplicates.

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

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

Schema description coverage is 100%, so baseline is 3, but the description goes further by explaining that 'properties' must conform to the collection schema and listing the rejection behavior for unknown keys, which is meaningful for an open additionalProperties object. It does not enumerate expected property shapes (delegated to knowledge_schema).

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

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

States a specific verb and resource: 'Manually insert data into a knowledge collection.' The word 'manually' implicitly separates it from automated ingestion siblings (source_ingest), and the required 'collection' enum makes the target unambiguous. It doesn't explicitly name a sibling, but the operation is clear.

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?

Provides a concrete prerequisite/alternative route: 'call knowledge_schema(collection=...) first to see expected properties.' That is actionable guidance for how to use the tool successfully. It stops short of stating when NOT to use it (e.g. use knowledge_query/knowledge_search for reads instead).

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower. The description adds genuinely useful behavioral context beyond the annotations: the deprecation status and the underlying Weaviate AsyncQueryAgent search mechanism. It does not describe result format, but an output schema exists, so this is minor.

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 deprecation warning is front-loaded in the first token of the description, followed by three tight sentences with no filler. Every sentence earns its place by routing the agent away from a stale tool.

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. The description fully covers what an agent needs: what the tool does, that it is deprecated, and where to go instead.

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

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

Schema description coverage is 100%, so all three parameters (query, limit, collections) are already documented in the schema. The description adds no parameter syntax or format details beyond that, making the baseline 3 appropriate.

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

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

The description gives a specific verb and resource ('Search knowledge store using natural language') and explicitly distinguishes itself from the sibling knowledge_search by naming it as the recommended replacement. An agent can route correctly without opening any schema.

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

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

It states an explicit when-to-use-this-vs-alternative rule: it is deprecated and the agent should use knowledge_search instead, with the concrete reason (Cohere reranking and Flash summarization, lower token usage). Nothing is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false. The description adds that results are found via near-object vector search, implying ranked semantic similarity rather than exact match, but does not cover return format, pagination, 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?

The description is a single front-loaded sentence with no wasted words. It communicates the core purpose and method immediately.

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

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

Given the rich input schema, output schema, and annotations, the description supplies the essential operation and method. It lacks sibling differentiation, but no return-value details are needed because an output schema exists.

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

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

Schema coverage is 100%, so object_id, collection, and limit are fully documented in the input schema. The description adds no parameter-level detail beyond what the schema already provides, making the baseline of 3 appropriate.

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

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

States a specific verb and resource: 'Find semantically related objects', and adds the method 'near-object vector search'. It is clear what the tool does, but it does not differentiate itself from sibling tools such as knowledge_search or knowledge_query.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The description only states what it does, leaving the agent to infer usage from the name and 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds genuinely new context beyond that: it reads from local CollectionDef objects and requires no Weaviate connection, which tells the agent this is a fast, offline-safe call.

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

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

Three short sentences, zero filler, and the core action is stated first. The implementation note and the usage hint each earn their place.

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

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

For a one-parameter, read-only introspection tool with a full output schema and rich annotations, nothing an agent needs in order to call it correctly is missing. Return-value shape is covered by the output schema, so the description need not describe it.

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

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

Schema description coverage is 100% and the single `collection` parameter is already documented as 'Collection to inspect (omit for all).' The description's plural 'collections' loosely implies the omit-for-all default, but adds no syntax or semantics beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource: 'Return property schemas for knowledge collections.' An agent can immediately tell this is a schema-introspection tool, distinct from write tools like knowledge_ingest. It does not explicitly contrast itself with near-neighbors such as knowledge_stats or knowledge_query, so sibling differentiation is only partial.

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

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

Gives a concrete when-to-use rule: 'Use this before knowledge_ingest to discover expected property names and types.' That ties the tool to a workflow step. It stops short of stating when NOT to use it or naming alternative introspection paths.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description earns credit for adding non-obvious behavior: results are merged and sorted by score, and filters are collection-aware with conditions skipped for collections lacking the property. This is exactly the kind of semantic that annotations cannot convey, though no rate limits or result-shape caveats are given.

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

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

Three short sentences, front-loaded with the core action and mode, then the collection-scope and merge/sort behavior. No filler, no repetition of schema content.

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

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

With an output schema present, return values need no explanation, and the description adequately covers scope, modes, and filter semantics for an 11-parameter search tool. The missing piece is routing guidance among the many knowledge_* siblings, which leaves the agent to infer tool choice.

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

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

Schema description coverage is 100%, so the schema already documents all 11 parameters including the alpha and search_type semantics. The description's mention of hybrid/semantic/keyword modes mirrors the search_type schema description rather than extending it, so the baseline 3 is appropriate.

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

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

States a specific verb+resource ('Search across knowledge collections') and names the three retrieval modes, which is more than a restatement of the name. However, it does nothing to distinguish itself from close siblings such as knowledge_query and knowledge_ask, which an agent could easily confuse with it.

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

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

The description never says when to pick this tool over knowledge_query, knowledge_ask, or knowledge_related, nor does it state any prerequisites or exclusions. The only usage-adjacent hint is that omitted collections means 'all', which is schema-level information rather than guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe-read profile is fully covered. The description adds useful context about the output shape (per-collection counts, optional property grouping) but says nothing about cost, limits, or behavior when a collection is omitted. With annotations carrying the safety burden, a 3 is appropriate.

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

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

A single front-loaded sentence with zero filler. The core action leads and the optional modifier follows, and every word 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?

The tool is simple (2 optional params) and has an output schema, so return values need not be explained here. Annotations cover the safety profile and the schema fully documents parameters. The only gap is the absence of routing guidance against siblings, but for a low-complexity stats tool this is close to complete.

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

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

Schema description coverage is 100%, so both parameters (group_by, collection) are already documented in the schema with examples and the enum of collections. The description restates 'per collection' and 'grouped by a property' but adds no syntax or semantics beyond the schema, which is the baseline-3 case.

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

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

States a specific verb and resource ('Get object counts per collection') plus the grouping capability, so the agent knows exactly what statistic is returned. It does not, however, name or distinguish itself from siblings like knowledge_query or knowledge_ask, so the differentiation must be inferred from the name.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. An agent must infer that this is the counting/aggregation tool versus knowledge_query (data retrieval) or knowledge_schema (structural metadata). Usage is implied by the name only.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and openWorldHint=true, so the agent knows this is a non-idempotent write pulling from the open world. The description adds 'bounded' (implying size limits) and 'exact byte identity' (implying verification), which are useful. But it omits auth requirements, where storage lives, and what a re-run over the same source does – notable gaps for a non-idempotent mutation.

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 efficient, though its terseness borders on under-specification rather than true economy.

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 there is only one well-documented parameter. Still, for a non-idempotent open-world write the description omits re-run behavior, storage semantics, and failure modes, leaving it thinner than the operation warrants.

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

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

Schema coverage is 100% and the single `source` parameter is fully documented with its accepted forms (local path, YouTube/Loom URL, HTTPS/HLS URL). 'Bounded' loosely hints at size constraints on the source but adds no syntax or format detail beyond the schema, so baseline 3 is appropriate.

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

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

It names a verb ('Acquire') and resource ('media') and states the destination ('private owned storage'), so the general intent lands. However, qualifiers like 'bounded' and 'exact byte identity' are jargon that doesn't sharpen what actually happens, and it never distinguishes this from close siblings such as source_ingest or media_source_inspect.

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

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

There is no when-to-use guidance, no prerequisites, and no reference to any alternative. With siblings like source_ingest and source_ingest_read in the set, an agent gets no signal for choosing this tool over 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?

Goes beyond the annotations by disclosing that instruments/mood/tags/tempo/key/meter are 'model interpretations' (non-deterministic, consistent with idempotentHint=false) and that PCM clocks and hashes tie each section to evidence. This is real behavioral context the structured fields don't convey.

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 purpose before the interpretive caveat and evidence note. Every sentence earns its place, though the caveat could be integrated more crisply.

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

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

With an output schema present, return values need not be explained, and annotations cover the safety profile. The description supplies the interpretive caveat and evidence model, leaving only explicit routing/prerequisite guidance unaddressed.

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

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

Schema description coverage is 100% and the nested request object is fully documented, so the schema carries the parameter burden. The description adds no syntax or format detail beyond it, making the baseline 3 correct.

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

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

States a specific verb and resource: 'Infer timed musical sections and properties from actual decoded audio.' An agent can tell this apart from generic siblings like audio_dsp_analyze or audio_transcribe, though it never explicitly names or contrasts with 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 phrase 'from actual decoded audio' implies a decoded-source precondition, but there is no explicit when-to-use guidance, no mention of alternatives (audio_dsp_analyze, audio_transcribe, media_perceive), and no exclusions or prerequisites such as authorization for submission.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, so the safety profile is partly covered. The description adds genuinely new behavioral context beyond the annotations: the removal cascades into invalidation of source-dependent caches. It still does not state that the operation is permanent/irrecoverable.

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

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

One sentence, front-loaded with the primary action and the scope, with the side effect tacked on efficiently. Zero 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?

For a one-parameter destructive tool, the description plus annotations (destructive) and the existing output schema cover most of what an agent needs. The remaining gap is that permanence/irreversibility and the recommended way to obtain a valid asset_id are never stated.

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

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

Schema coverage is 100% with a single fully documented asset_id parameter (SHA-256 pattern, 'paths are forbidden'), so the schema carries the load. The description's 'verified owned asset' adds a mild ownership/verification nuance but no format or sourcing detail beyond the schema. Baseline 3 applies.

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

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

Names a specific verb (remove) and resource (verified owned media asset), and the qualifier 'verified owned' narrows it against the many sibling media/image/audio tools. It does not explicitly contrast with siblings like media_assets_list or media_info, but the intent is unambiguous.

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

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

No statement of when to use this versus alternatives, no prerequisite that asset_id comes from media_acquire or media_assets_list, and no warning about when removal is inappropriate or irreversible. The agent must infer all routing 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds genuine behavioral context beyond them: it discloses that listing triggers 'fresh byte checks' and can surface 'explicit unhealthy states'. This tells the agent the call is not a pure cached read and that results may include error states.

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, economy that gets the read-only, paginated nature across quickly. It borders on cryptic (

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 covering return values and annotations covering safety, the description need not explain results. What remains missing is sibling routing and any hint of cost/latency implied by the fresh byte checks, but the structured metadata supplies most of what an agent needs.

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

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

Schema description coverage is 100%, so limit and offset (including the SHA-256 ordering) are already fully documented. The description's 'bounded page' phrasing only echoes the pagination concept without adding format or ordering detail, so the baseline 3 applies.

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

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

The verb 'List' is clear and the name supplies the resource ('media_assets'), but the description itself never names what is listed and never distinguishes it from siblings like media_info, media_metadata, or media_source_inspect. 'List a bounded page' is a vague purpose statement that leans on the title to be understood.

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 is given, no exclusions, and no alternative sibling is named. An agent cannot infer from the text whether this should be preferred over media_info or media_metadata for inspecting owned assets.

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

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

Annotations already signal non-read-only, open-world, non-idempotent, non-destructive behavior. The description adds only the vague phrase 'with submitted support' and does not disclose the dry_run default (true), the authorize_submission gate, or that a local file with a verified hash is required. For a submission-oriented tool these are material omissions.

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?

It is a single front-loaded sentence with no redundancy, but the phrasing is vague filler ('with submitted support') rather than information-dense, so brevity comes at the cost of substance.

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

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

This is a complex tool with a nested request object, many defaulted limits, an authorization flag, and hash verification, plus an output schema. The one-line description omits the dry-run default, the submission authorization requirement, and the local-source constraint, leaving the agent under-informed about how to invoke 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 100%, so the nested request object, limits, dry_run, and sha256 pattern are already documented structurally. The description contributes no additional parameter meaning, which is the baseline-3 case when the schema does the heavy lifting.

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 'caption' and the objects 'timed audio, visual and combined occurrences' give a rough sense that this generates event captions over media, but the trailing phrase 'with submitted support' is cryptic and no sibling (media_count_events, media_ground_events, media_perceive) is distinguished. An agent can guess the domain but not the precise operation.

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

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

There is no when-to-use guidance, no mention of prerequisites (local file, sha256), and no routing to or away from the closely related event tools. The agent must infer usage entirely from the schema.

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

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

Annotations already disclose readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is partly covered. The description adds real context beyond that: counts derive only from 'admitted records in submitted evidence,' overlapping records are counted distinctly, and frame sampling leaves gaps where events may be missed. These are meaningful behavioral disclosures not present in the annotations.

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

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

Two short paragraphs, front-loaded with the core action, and the second paragraph adds distinct caveats rather than padding. The dense jargon costs a little clarity, but nothing is redundant or 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?

An output schema exists and annotations cover safety, so the description needn't explain return values. But for a tool with a 17-property nested request, it never explains the dry_run-default-true / authorize_submission submission workflow or when this is preferable to the many sibling event tools, leaving a real gap.

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

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

Schema description coverage is 100% and the single nested 'request' object carries its own description, so the schema does the heavy lifting. The description adds no syntax or semantics for parameters like dry_run, authorize_submission, or the limits block. Baseline 3 applies when the schema already documents everything.

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 first sentence gives a specific verb and resource: 'Count ... occurrences of a target in bounded source windows.' An agent can grasp that this counts target events within windowed media. However, the phrasing is jargon-heavy ('retained inferred occurrences') and it makes no attempt to distinguish itself from near-siblings like media_caption_events or media_ground_events.

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

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

There is no when-to-use guidance, no prerequisites, and no alternatives named despite many overlapping event/analysis siblings. The second paragraph states counting caveats rather than selection conditions, so an agent gets no help deciding between this and media_ground_events or media_caption_events.

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 annotations covering safety flags, the description still adds meaningful behavior: prepare retains source intervals, frame clocks, grade/audio decisions and previews; assemble gates decoding, timeline, black spans and audio loudness; beat grids and approvals are only caller assertions, not verified semantics. It also discloses prerequisites (FFmpeg and Pillow must be installed) and that no provider is invoked, which the annotations do not convey.

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 phase model, then the prepare behavior, then assemble requirements and caveats. Dense jargon such as 'measured prepare and approval workflow' costs a little clarity, but every sentence carries information with 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. Given two top-level parameters with 100% schema coverage, the description supplies the missing workflow context, prerequisites and the assertion-versus-verification boundary, leaving little an agent would need but cannot find.

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

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

Schema description coverage is 100%, so the schema already documents the request union, beats, grade, approvals and include_image. The description reinforces the prepare/assemble split and clarifies that beat grids are declared, not detected, but does not add format or syntax detail beyond the schema. Baseline 3 applies.

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

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

States specific verbs (prepare, assemble) and the resource (bounded local footage) with a two-phase workflow, and explains what each phase produces. It does not name sibling tools such as video_clip_export or image_edit, so an agent must infer differentiation, but the purpose itself is unambiguous.

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

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

The description implies usage through the workflow itself (prepare first, then assemble with the exact manifest and approvals), which is a real sequencing constraint. However it never states when to choose this over alternatives like video_clip_export, nor any when-not condition, so guidance beyond the ordering is inferred rather than 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=true, and idempotentHint=false. The description adds the useful caveat that returned scores are uncalibrated, but it omits behavioral details such as dry-run defaulting, authorization requirements, expected source hash verification, and external-call 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?

The description is a single front-loaded sentence with no wasted words. For a tool with a deeply nested request object and many behavioral controls, however, it is too terse to be considered appropriately sized.

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 annotations cover some safety traits. Still, the description is incomplete for a complex media-grounding tool: it does not explain dry-run behavior, submission authorization, source-hash verification, or how to choose this tool over related media event tools.

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

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

Schema description coverage is 100%, so the schema itself documents all parameters, including nested limits and required fields. The description adds no additional parameter meaning beyond the schema, which establishes the baseline of 3.

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

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

The description has a verb and resource: 'Ground a query in source-supported intervals.' However, 'source-supported intervals' and 'uncalibrated scores' are abstract and do not clarify the media modality or distinguish this tool from siblings such as media_caption_events or media_count_events.

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 when-to-use context, no alternatives, and no preconditions for selecting this tool. An agent has no guidance beyond the name and schema.

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

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

Annotations carry the safety profile, and the description adds real context beyond them: the FFprobe dependency, the bounded private stable snapshot, and the explicit statement that no provider upload occurs and no watched coverage is established. The 'snapshot' phrasing also explains why readOnlyHint is false for an inspect-style tool.

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

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

Three short sentences, front-loaded with the verb and resource list, then constraints. No filler or repetition; every sentence earns its place.

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

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

With an output schema present, return values need not be described, and the description covers the operation's scope, side-effect posture, and external dependency. Minor gap: no explicit guidance on selecting this over the near-name-collision siblings like media_metadata or media_source_inspect.

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

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

Only one parameter, fully documented in the schema (LOCAL_FILE_ACCESS_ROOT constraint, 1-4096 chars). The description reinforces 'local media bytes' but adds no format or path-syntax detail beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb ('Inspect') plus a concrete resource set: local media bytes, stream metadata, rotation, audio, chapters. That distinguishes it from provider-oriented siblings such as media_metadata and media_source_inspect, though it never names an alternative tool 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 clauses 'no provider upload' and 'does not establish watched coverage' implicitly scope it to local, non-ingesting inspection, which is useful routing signal. However, there is no explicit when-to-use statement or named alternative among the many media_* 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds meaningful context beyond that: it performs no download, inference, or upload, telling the agent this is a lightweight operation. It stops short of describing error behavior or metadata coverage, so not 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?

One front-loaded sentence with zero padding; the operation is stated first and the cost-avoidance qualifier second.

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 annotations carry the safety profile. But 'explicit metadata' leaves the actual payload ambiguous, and with multiple overlapping siblings (video_metadata, media_info, media_source_inspect) the definition should clarify what this returns and when to prefer it.

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

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

Schema description coverage is 100% with a single, well-documented 'source' parameter (local path, YouTube/Loom URL, or HTTPS/HLS URL). The description adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a verb+resource (retrieve metadata) but 'explicit metadata' is vague about what metadata is returned, and nothing distinguishes it from siblings like video_metadata, media_info, or media_source_inspect. An agent cannot tell from the text why it would pick this over video_metadata.

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 'without downloading video, inference or upload' implies the use case (cheap metadata lookup that avoids heavy processing), which is a real contextual hint. However, no alternative is named and there is no explicit when/when-not guidance relative to the many metadata-adjacent 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?

Annotations establish a non-read-only, open-world, non-idempotent call to an external provider, and the description meaningfully extends this: dry runs make no provider calls, submission needs an exact grant and a configured account, and sampled frames leave visual gaps (a real accuracy caveat). That is substantive disclosure beyond structured fields, though it omits cost/rate-limit 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?

Three tight sentences with the core purpose front-loaded and operational facts following. Every clause carries information; no padding or restatement of the title.

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

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

An output schema exists, so return values need not be explained, and the description covers the dry-run/submit gating, the account/grant prerequisites, and the sampling limitation. The remaining gap is sibling disambiguation, which keeps it from a 5.

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

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

Schema coverage is 100%, so every field including the nested limits object is already documented, making 3 the baseline. The description adds only tangential mapping detail ('model intervals map back to source seconds') and the sampling-gap caveat rather than clarifying specific parameters like fps, window_seconds, or authorize_submission.

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 ('infer') and resource ('separate spoken and visible source evidence') with a clear scope ('across bounded AV windows'), which distinguishes it from pure-audio (audio_transcribe) or pure-vision siblings. However, it never names an alternative in the sibling list, so the agent must infer the boundary itself.

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

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

The description implies a two-phase workflow (dry plan first, then submission) and states the precondition for submission ('exact workflow grant and configured account'). That is useful operational context, but it gives no explicit when-to-use vs video_analyze, audio_transcribe, or video_analyze_windows, leaving the choice to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower, yet the description adds genuinely useful behavior beyond them: this call performs no network contact and no download, i.e. it is a pure local syntax/capability check. It does not describe the return format, but an output schema is present.

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

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

One sentence, front-loaded with the verb and resource, with the distinguishing constraint appended. No filler whatsoever.

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?

Complete enough to call correctly: the parameter is fully documented in the schema, the return contract is covered by the output schema, and annotations supply the safety profile. The only residual gap is a slightly clearer statement of when to prefer this over media_info or media_acquire.

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 at 100% schema description coverage ('Local video path, YouTube/Loom URL, or HTTPS direct video/HLS URL'), so the schema fully documents accepted input forms. The description adds nothing parameter-specific. Baseline 3 is appropriate when the schema does all the work.

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: 'Inspect source syntax and capabilities.' The qualifying phrase 'without contacting or downloading it' implicitly carves out territory from siblings like media_info, media_acquire, and source_ingest, so an agent can distinguish this as a dry validation step. It stops short of a 5 because no sibling is ever 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?

The 'without contacting or downloading' clause implies the right moment to call it (pre-flight validation before acquisition/ingest), but the description never states that usage explicitly and names no alternatives. Usage must be inferred from the negative qualifier rather than read directly.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so the safety and idempotency profile is covered structurally. The description adds a mild behavioral note that results are limited to already-registered devices, but says nothing about result size, pagination, or what happens on an empty registry. With annotations carrying the main burden, a 3 is appropriate.

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 a clear verb and no filler. It is efficient, though the trailing phrase 'and their explicit capabilities' is slightly ambiguous and does not earn as much as a routing or scoping clause would.

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 annotations fully cover the read-only/idempotent/closed-world profile. Parameters are documented in-schema, leaving the description with little it must still carry. Adequate for a simple zero-required-parameter discovery call.

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 have 100% schema description coverage ('Optional exact device tag', 'Optional exact simulated device type'), so the schema already explains them. The description mentions neither filtering nor the fact that both filters are optional/exact-match, adding no meaning beyond the structured fields. Baseline 3 applies.

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

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

States a specific verb (Discover) and resource (registered simulated devices) plus an extra output dimension (their explicit capabilities). It is clear on its own, but gives no signal distinguishing it from the sibling mhs_* family (mhs_read, mhs_meta_info, mhs_health_check), so an agent cannot route between them from the text alone.

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

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

No when-to-use, when-not-to-use, or alternative named. The description never says to call this before mhs_read/mhs_write, nor whether discovery is required prior to other operations in the mhs family. Only implied usage can be inferred.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds context that it acknowledges a failed-write gate (consistent with a non-read-only operation) but does not clarify what state changes, whether acknowledgement is reversible, or what a 'fresh simulated' inspection returns.

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

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

A single compact sentence with the action front-loaded. However, the second clause is dense and cryptic rather than informative, slightly reducing value per word.

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. Still, the description leaves the core mechanics ('health gate', 'acknowledge', 'mhs') unexplained for a tool in a family with five siblings, so an agent lacks enough 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?

With a single optional parameter and 100% schema description coverage, the schema already documents device_id and its 'omit for all devices' default. The description adds no semantics beyond the schema, so baseline 3 applies.

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

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

The verb 'inspect' and resource 'health' are present, but 'mhs' is never expanded and the second clause ('acknowledge a failed-write health gate') is cryptic enough that an agent cannot cleanly predict what the tool does. It fails to distinguish itself from siblings like mhs_read, mhs_reset, or mhs_meta_info.

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 call this versus mhs_read/mhs_write/mhs_reset, and no exclusion criteria or prerequisites. The phrase 'failed-write health gate' hints at a trigger condition but never explains it as 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is covered. The description adds context about the returned information (values, directions, effective simulated limits) but does not disclose permissions, failure modes, or other behavioral traits beyond what annotations and the output schema provide.

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 extraneous text. Every word contributes to describing the tool's scope, making it appropriately sized for a simple read operation.

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

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

Given the tool's low complexity, the rich schema (100% coverage), presence of an output schema, and full annotations, the description is nearly complete for invocation. It could be improved by noting when this tool is preferred over mhs_read or mhs_discover, but it is sufficient for an agent that already knows the MHS family.

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

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

The schema has 100% description coverage for the single 'device_id' parameter, so the baseline is 3. The description adds no additional meaning about this parameter beyond what the schema already states.

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 ('Inspect') and a specific set of resources ('current device values, directions and effective simulated limits'). It is clear what the tool does, though it does not explicitly differentiate itself from likely siblings such as mhs_read or mhs_discover.

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 indication of when to use this tool versus alternatives like mhs_read, mhs_write, or mhs_discover, nor any prerequisites or exclusions. The purpose statement implies a use case, but no explicit guidance is 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?

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, and openWorldHint=false. The description does not explain why a tool named and described as 'Read' is not read-only, nor does it detail side effects, authentication needs, or rate limits. The phrase 'retain independently generated image bytes' hints at a storage side effect but is ambiguous.

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?

Single sentence with no wasted words, front-loaded with the primary verb 'Read'. However, the second clause about retaining image bytes is vague and could be clearer.

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

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

Given three required parameters, a nested object, and rich schema/annotations/output schema, the description should clarify when to use this versus mhs_write and what 'retain' means. It leaves those gaps, making it incomplete for reliable tool selection.

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

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

Schema description coverage is 100%, so the schema already documents device_id, capability, and params. The description adds no parameter-level detail, but baseline is 3 when the schema carries the load.

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 'Read' and resource 'declared simulated sensors', plus a secondary operation 'retain independently generated image bytes'. It does not differentiate from sibling tools like mhs_write or mhs_meta_info, but the core read purpose is clear.

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 explicit when-to-use, prerequisites, or alternatives are provided. The only usage hint is implicit in 'declared simulated sensors' and 'retain image bytes', but there is no guidance on when to choose this over mhs_write or how to obtain capability via mhs_meta_info.

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

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

Annotations already declare the operation profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=false), lowering the bar. The description contributes the useful fact that recovery requires separate authorization, but says nothing about preconditions, expected state before/after, or the replay/receipt behavior that matters for safe retries.

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 dual behavior is stated up front. It is efficient, though its terseness borders on under-specification rather than excess.

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 a full output schema and rich annotations, the description needn't cover returns or safety, and the two modes plus the authorization caveat are present. Still, for a device-mutating reset it omits prerequisites and state assumptions, so it is only minimally complete.

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

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

Schema description coverage is 100% and the enum itself explains that 'estop' latches output off while 'soft' requires host authority, so the description adds nothing beyond the structured fields. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description names a specific action and object ('latch a simulated emergency stop' / 'perform recovery') so its purpose is inferable, but the framing sits awkwardly against the tool name 'reset' and the description gives no differentiation from adjacent siblings such as mhs_read, mhs_write, or mhs_discover. An agent can guess this is the estop/recovery control for an MHS simulator, but only after cross-reading the name and 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?

'Separately authorized recovery' implies that one branch requires host authority, hinting at when the soft path applies, but there is no explicit when-to-use/when-not or named alternative. The mode enum carries the selection logic rather than the description, leaving usage 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?

Beyond the annotations (idempotent, non-destructive, non-read-only), the description discloses the approval model: confirm=True never grants authority, soft overrides need host approval bound to command/state/limits, terminal IDs replay receipts, and a resumed proposal may attempt its first action only after exact approval. This is meaningful behavioral context the annotations cannot convey.

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?

Purpose is front-loaded in the first sentence, followed by tightly packed approval and replay rules. It is appropriately short for a high-complexity mutation tool, though the phrasing is dense and jargon-heavy ('exact authority proposal', 'bound to this command, state and limits').

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

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

With an output schema present, return values need not be described, and the description covers the key non-obvious behaviors: approval gating, confirm semantics, receipt replay, and pending-proposal resumption. An agent has enough to call it correctly, though the read/write sibling relationship is left implicit.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters including confirm and command_id. The description reinforces that confirm grants no approval and that command_id replays a receipt, but this largely overlaps the schema text rather than adding new syntax or constraints. Baseline 3 applies.

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

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

The description states a specific verb (apply a write) and resource (a simulated device write via mhs_*), and distinguishes the two outcomes: executing the write or returning its authority proposal. It does not explicitly name siblings like mhs_read or mhs_reset, so an agent must infer the read/write split from the family naming.

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 implies the tool is the write path and states conditions under which separate host approval is required (soft overrides, confirmation-required operations), but it never says when to choose this over mhs_read, mhs_reset, or mhs_meta_info. Usage is inferable rather than spelled out.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, but the description adds substantive behavioral context beyond that: profiles declare support statically, and inspection performs no connectivity or model test. This prevents the agent from mistaking this for a live validation tool. It stops short of describing return values or failure behavior (e.g., does it error on unsupported selections?), but with annotations covering the safety profile, this is meaningful added value.

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 the important caveat about no connectivity testing immediately after. No filler, though the second sentence is slightly cryptic without the schema 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?

Given an output schema exists (so return values needn't be explained) and annotations plus full schema coverage handle safety and parameters, the description supplies the one crucial missing piece: that this is a static inspection with no live testing. For a low-complexity, two-optional-parameter tool, this is nearly complete, missing only explicit error semantics.

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

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

Schema description coverage is 100% – both parameters have detailed descriptions listing accepted backend strings and capability enums. The description adds nothing beyond the schema for parameter meaning, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Inspect') and resource ('configured operation support'), and the second sentence clarifies what it does not do. It doesn't need to distinguish from siblings since none of the other tools perform provider capability checks, but the phrasing 'operation support' is broad enough that an agent must lean on the schema for specifics.

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: check support before selecting operations, and reject unsupported selections. The second sentence warns that no connectivity or model test occurs, which implicitly tells the agent not to use this as a health check. However, there is no explicit when-to-use or when-not-to-use statement.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds only the return contents ('evidence tier and confidence'), which the output schema largely already covers, and says nothing about how sources are weighed or what tiers mean.

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 wasted words, and the action plus return value are front-loaded. Slightly more detail on source handling could have been justified but is absent.

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

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

An output schema exists, so return values need not be explained, and structured fields carry the parameter and safety info. For a simple read-only assessment tool the description is adequate, though it could route the agent to siblings.

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

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

Schema description coverage is 100%, so all three parameters (claim, context, sources) are fully documented in the schema. The description adds no semantics beyond that, which is the expected baseline when the schema does the heavy lifting.

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 ('Assess a claim against sources') plus the output ('evidence tier and confidence'). It is clearly distinguishable from research siblings, though it does not explicitly name an alternative tool.

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

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

No guidance on when to use this versus related tools like research_deep, research_execute, or research_paper_citations. An agent must infer the context 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the returned field set (affiliation, paper count, citation count, h-index), which is useful context, but says nothing about pagination, rate limits, or empty-result behavior beyond the annotation bar.

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

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

Two sentences, zero filler, with the core action ('search academic authors') front-loaded and the return shape following immediately.

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

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

For a read-only, two-parameter search with an output schema and full schema coverage, the definition covers the essentials. The one real gap is the absence of routing guidance versus sibling research_* tools.

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

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

Schema description coverage is 100%: 'query' and 'limit' are fully documented with constraints (maxLength 200, minimum 2, limit 1-100). The description adds no parameter syntax or format guidance, so the baseline 3 applies.

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

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

States a specific verb and resource ('Search for academic authors') plus the provider ('Semantic Scholar'), which naturally separates it from research_paper_search and research_paper_details. It does not explicitly name or contrast with those siblings, 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?

No when-to-use, when-not-to-use, or alternative-tool guidance is given. The description only says what the tool does, leaving the agent to infer that author-level search differs from paper-level 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?

Annotations only cover readOnlyHint and openWorldHint; the description goes further by disclosing a consequential behavioral trait: CONFIRMED and STRONG INDICATOR proposals degrade to UNKNOWN because this route neither retrieves nor verifies. That materially warns the agent about output reliability, which the annotations do not convey.

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

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

Two short, front-loaded sentences plus a phase list, with zero filler. The most important constraint (no retrieval, tier degradation) is stated up front.

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

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

With an output schema present and annotations covering the safety profile, the description only needs to convey routing and behavioral caveats, which it does via the phase list and the UNKNOWN-degradation warning. Adequate, though it could be stronger with an explicit sibling comparison.

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

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

Schema description coverage is 100%, so topic, scope, and thinking_level are already fully documented in the schema, including enums and defaults. The description adds no parameter-level detail beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb+resource ('Run three-phase model-only synthesis') and enumerates the phases, making the operation concrete. The qualifier 'without external source retrieval' implicitly separates it from retrieval-based siblings like research_web or research_execute, though no sibling is named 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?

The phrase 'model-only synthesis without external source retrieval' implies when this route is appropriate versus the retrieval-oriented research siblings, but there is no explicit when-to-use/when-not statement or named alternative. Usage is inferred rather than stated.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds real behavioral value beyond that: a concrete four-phase pipeline (Document Mapping -> Evidence Extraction -> Cross-Reference -> Synthesis) and the guarantee that claims carry evidence tiers and citations.

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 compact sentences with the core action front-loaded, followed by the phase pipeline and output guarantee. No filler; every line contributes.

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 annotations plus full schema coverage carry safety and parameters. Behavior is well described; the only real gap is usage routing against sibling research tools.

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

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

Schema description coverage is 100%, so the five parameters (urls, file_paths, instruction, scope, thinking_level) are already documented in the schema. The description adds no syntax, format, or interaction detail for them, so baseline 3 applies.

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

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

States a specific verb and resource ('Run multi-phase deep research grounded in source documents') and clarifies the domain as document-grounded research. However, it does not distinguish itself from close siblings like research_deep or research_execute, leaving the agent to infer the boundary.

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

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

No explicit when-to-use, when-not-to-use, or alternative routing is given. 'Grounded in source documents' implicitly contrasts with research_web, but the agent must infer whether to pick this over research_deep, research_execute, or research_plan.

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

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

Annotations already declare openWorld=true, readOnly=false and non-idempotent, so the agent knows this mutates external state. The description adds real value beyond that: byte-checking of supplied originals, fail-closed behavior on unknown price ceilings, and the explicit rule that model tiers never establish CONFIRMED. It does not, however, describe run_id reuse or revision/pagination 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?

Seven short sentences, each carrying a distinct rule, with the prepare/execute scope front-loaded. The telegraphic style ('Unknown price ceilings fail closed') is dense but not padded.

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

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

For a complex nested schema with an output schema and annotations present, the description covers the safety envelope (authorization, dry-run, fail-closed) that structured fields cannot convey. It omits run_id/resume semantics and mode-to-field mapping, but nothing critical for a correct first call is missing.

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

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

Schema description coverage is 100% and there is effectively one nested request object, so the baseline is 3. The description implies the mode semantics (URL execution vs inference) but does not map any of that to named fields such as mode, authorize_source_access, or dry_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?

States a specific verb pair and resource ('Prepare or execute source-preserving research') plus the scoping constraint of a single global allowance, which distinguishes it from lightweight siblings like research_plan or research_web. It stops short of naming which sibling to choose instead, so it is clear but not fully differentiated.

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 concrete conditional guidance: dry runs trigger no provider/URL calls, URL execution needs source-access authorization, inference needs submission authorization, and Google hosted research is a separate route. This tells an agent when routes are permitted, though it never names an alternative sibling tool to route to.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — no note on pagination, result volume, coverage of the citation graph, or auth requirements — leaving the behavioral burden entirely on structured fields.

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

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

A single front-loaded sentence with zero filler, appropriately sized for a three-parameter read tool. It is efficient rather than padded, though it borders on under-specified.

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 parameter schema is complete. However, for a graph-traversal tool an agent would benefit from knowing the relationship semantics and any limits; the description stops at the minimum viable level.

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

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

Schema description coverage is 100%, so paper_id, direction, and limit are already fully documented in the schema, establishing the baseline of 3. The phrase 'citations or references' echoes the direction enum but adds no format or edge-case meaning beyond it.

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

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

States a specific verb ('Get') and resource ('citations or references for a paper') that clearly maps to the tool name. It is distinguishable from research_paper_search and research_paper_details by the citation/reference focus, 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 when-to-use guidance, no prerequisites, and no mention of alternatives such as research_paper_details for metadata or research_paper_recommendations for related work. The agent must infer the niche from the tool name alone.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and external-lookup profile is covered. The description adds the accepted identifier forms, which is useful operational context, but says nothing about lookup failures for invalid IDs or rate limiting; the output schema covers return values, so a 3 is fair.

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

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

Two short sentences, front-loaded with the core action, with zero filler. The second sentence duplicates schema content, which slightly reduces its efficiency, but the structure is clean and easy to scan.

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 single-parameter read tool with full schema coverage, an output schema, and safety annotations, the description supplies everything needed to invoke it correctly. Only the sibling-routing guidance is absent, which is a minor gap given the explicit ID formats.

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

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

Schema description coverage is 100% for the single paper_id parameter, and the description merely restates the same format details (DOI:/ArXiv: prefixes) already present in the schema. Baseline 3 applies since the schema does the heavy lifting and the description adds no meaning beyond it.

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

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

States a specific verb ('Get detailed metadata') and resource ('a specific paper'), making the lookup-by-ID intent clear. It does not explicitly differentiate itself from close siblings such as research_paper_search or research_paper_citations, but the 'specific paper' framing implies single-item retrieval rather than discovery.

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: the agent can infer this is the tool to call once it already holds a paper identifier. There is no explicit guidance on when to prefer it over research_paper_search (to obtain an ID first) or research_paper_citations, and no stated preconditions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe, external-facing read. The description adds that results come from Semantic Scholar's recommendation engine, but says nothing about rate limits, API key/auth requirements, or result ordering — modest added value beyond the annotations.

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

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

Two short, front-loaded sentences with no filler. The second sentence (mechanism) earns its place by telling the agent what engine backs the results, though it borders on redundancy with 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 two params are fully schema-documented. However, for a tool whose selection depends on distinguishing it from other research_paper_* siblings, the absence of any usage context leaves a real gap.

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

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

Schema description coverage is 100%, so both parameters (seed_paper_ids, limit) are already documented in the schema. The description only says recommendations are 'based on seed papers', adding no syntax, ID format, or limit interplay beyond the schema.

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

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

States a specific verb (get) and resource (paper recommendations) with the mechanism (Semantic Scholar recommendation engine based on seed papers). It is distinguishable from sibling tools like research_paper_search and research_paper_citations, though it doesn't 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?

The description implies you need seed papers but gives no guidance on when to choose this over research_paper_search, research_paper_citations, or knowledge_related. No prerequisites, no exclusions, no alternatives named.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety/external-call profile is covered. The description adds useful context about what is returned (abstracts, citation counts, TL;DR), but says nothing about result caps, pagination, rate limits, or API-key requirements for the external Semantic Scholar call.

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: the action and source come first, then the return contents and filter capabilities. 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?

With an output schema present, return values need not be explained, and annotations cover safety; the description covers purpose and filter scope adequately. It is only slightly short of complete for lacking any guidance on when this search is preferred over the sibling paper tools.

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

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

Schema description coverage is 100%, including the year_range format and fields_of_study examples, so the schema carries the parameter burden. The description merely restates that field-of-study, year, and open-access filtering are supported, adding no syntax or semantics beyond the schema.

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

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

States a specific verb and resource ('Search academic papers') plus the backing source ('Semantic Scholar'), and enumerates the returned payload (metadata, abstracts, citation counts, TL;DR). This clearly separates it from siblings like research_paper_details, research_paper_citations, and research_paper_recommendations.

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 says what filters exist but never says when to choose this tool over research_paper_recommendations or research_paper_details, nor any prerequisite or exclusion. Usage is only inferable from the verb 'search'.

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