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

With no annotations provided, the description carries the full disclosure burden and does so thoroughly: 'Reads only', 'never the live network', 'calls no other tool, signs no payment, and makes no side-effecting or network request', plus guaranteed `executes: false` and absence of a `model` field. It even points to SKILL.md for the full contract.

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 core purpose is front-loaded, followed by essential safety/behavior disclosures and a pointer to the full contract. Every sentence adds distinct information; it is dense but not padded, and the structure follows importance 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?

For a tool with no output schema and no annotations, the description supplies the proposal's key fields (product, MCP tool, price shape), its execution semantics, and its return contract (`executes: false`, no `model` field). The reference to SKILL.md covers edge details without bloating the description.

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

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

Schema description coverage is 100%, and the schema already richly explains `question` (untrusted, only selects fixed compositions) and `budgetUsd` (reorders suggestions, never invents a price). The tool description adds useful context about output shape but no additional per-parameter meaning, 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 opens with a specific verb+resource: 'Propose a WAVE flow (product + MCP tool + price shape)' for a plain-language media-processing goal. It also distinguishes itself from execution siblings by stating 'never executes' and 'Returns a proposal object for you to call yourself.'

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 clearly scopes when to use it: any media-processing goal stated in plain language where a WAVE flow proposal is needed. It does not explicitly name alternatives or state when not to use it, but the heavy emphasis on read-only, non-executing behavior makes the boundary with execution-focused siblings clear.

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

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

There are no annotations, so the description carries the transparency burden. It adds useful behavioral detail about which fields each command variant requires and which commands need no extra fields. However, it does not disclose side effects, permissions, camera-managed prerequisites, or response/error behavior, making it adequate but not rich.

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 one dense, well-organized sentence that front-loads the purpose and endpoint, then uses semicolon-separated mappings for all command variants. Every piece of content contributes directly to correct invocation, with no filler or repetition.

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

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

Given the complexity of 11 parameters and 13 command variants, the description covers the essential combinatorial logic completely, including which commands require no extra fields. It omits return-value and error details, but those are not necessary for an agent to select and invoke the command 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. The description adds a critical layer by mapping each `command` enum value to its required parameters, e.g., set_white_balance uses temperature+tint and set_shutter uses angle. This materially reduces ambiguity for the agent, though units and value ranges are left to 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 clearly identifies the action ('Send a control command to a managed camera'), gives the endpoint, and enumerates all supported command variants. It does not explicitly differentiate from the only other camera-related sibling, wave_switch_camera, but the purpose is specific enough to avoid major confusion.

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

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

The description provides clear context for when to use this tool: when sending control commands to managed cameras. It also gives practical guidance on selecting the correct parameter subset per command variant. It does not mention alternatives or exclusions, but the boundary against stream/design/production tools is reasonably evident.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'Create a clip' and gives parameter hints; it does not mention whether processing is asynchronous, what the response contains, side effects, or failure modes. This is a significant gap for a mutating POST operation.

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

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

The description is two sentences with no wasted words. It front-loads the action and endpoint, then immediately clarifies the key parameter semantics. It is compact, readable, and easy for an agent to parse.

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

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

This is an 11-parameter tool with no annotations and no output schema. The rich schema covers invocation inputs well, but the description provides no information about return values, processing behavior, or post-invocation expectations. It is minimally viable but leaves meaningful gaps.

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

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

Schema description coverage is 100%, so the schema already explains all parameters. The description adds the time-string pattern and notes that `out`/`duration` are optional, but these details are largely repeated in the schema descriptions. No new parameter semantics are provided beyond the schema.

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

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

The description states a specific action ('Create a clip from a recording') and includes the exact endpoint (POST /v1/clips). It clearly names the input resource (recording) and the output object (clip), making its purpose unambiguous and distinct from sibling stream/production tools.

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

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

The description provides clear context: use this tool to create clips from an existing recording ID, with `in` and optionally `out`/`duration` as time strings. It does not explicitly mention when-not-to-use or alternatives, but no sibling clip tool exists, so the usage context is sufficient.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It only says 'Create' and gives the HTTP method; it does not mention side effects, idempotency, permissions, validation behavior, or what happens on success/failure.

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, direct sentence with the action and endpoint front-loaded. There is no wasted content or unnecessary elaboration.

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 description plus the fully documented schema is sufficient for basic invocation of a create operation, but there are gaps: no return-value information, no usage context, and no annotation-provided safety cues. It is adequate but not complete for a tool with five parameters and no output schema.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no additional meaning about the parameters, which is acceptable but does not raise the score above the 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?

The description states a specific verb ('Create'), a specific resource ('multi-camera production'), and the exact endpoint ('POST /v1/productions'). This clearly distinguishes it from sibling tools like wave_create_stream and wave_list_productions by resource type and action.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites such as needing existing streams for stream_ids. The description only states what the tool does, not when to choose it.

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

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

With no annotations, the description carries the full behavioral burden, but it only conveys that this is a creation mutation. It does not state permissions, quota/cost implications, whether the stream starts immediately, or what the response contains (e.g., stream ID, ingest URL). The Cloudflare Stream live input detail adds some context but not enough to cover side effects or return behavior.

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

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

The description is a single sentence with no filler; the key verb, resource, and endpoint appear early. The Cloudflare Stream live input detail is the only extra context and it earns its place. This is appropriately front-loaded and concise.

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 create operation with no annotations and no output schema, the description is too thin: it omits what the created stream looks like, what is returned, and how creation relates to starting the stream. The schema covers parameter formats well, but the tool-level behavior and downstream workflow are missing. A minimally complete description would at least mention that creation is separate from starting and returns a stream identifier or ingest credentials.

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

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

The input schema already covers all six parameters with descriptions, enums, and defaults, so schema description coverage is 100%. The description itself adds no parameter-level meaning, but per the high-coverage baseline, a score of 3 is appropriate. No parameter semantics are sufficiently missing to lower the score.

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

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

The description clearly states a create action on a stream resource and includes the REST endpoint, so the agent knows exactly what operation this is. It is not tautological and the verb 'create' distinguishes it from list/start/stop siblings, but it does not explicitly contrast itself with those siblings.

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

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

The description gives no conditions for when to create a stream versus listing, starting, or stopping one, and it names no alternatives. The verb implies creation is the intended use, but there are no prerequisites, exclusions, or routing cues. The agent is left to infer context from the tool name and 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?

With no annotations provided, the description carries the full burden. It discloses that the tool writes a contract file, validates against schema and acceptance-tests, and returns specific outputs (validator line, key counts, written path). It does not mention overwrite behavior or failure handling if validation fails, but the core behavior is clearly conveyed.

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

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

The description is a single dense sentence with no filler. It front-loads the primary action, then adds the validation step and return values, earning 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?

For a relatively simple two-parameter tool with no output schema, the description covers purpose, precondition, processing, validation, and return values. It could more clearly state what happens if validation fails or whether an existing output file is overwritten, but the essential context is present.

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

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

Schema description coverage is 100%: both 'extract' and 'out' have meaningful descriptions and defaults in the input schema. The tool description adds no new parameter-level 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 names a specific verb ('Compose') and resource ('design-contract.json') plus the validation step, making the tool's function concrete. It also references an 'already-extracted pen-extract dir', which distinguishes it from extraction tools like wave_design_extract and check-only tools like wave_design_contract_check.

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 'already-extracted' clearly signals that this tool is meant to be used after wave_design_extract, giving useful positional context. It does not explicitly name alternatives or state when not to use it, so it falls short of a perfect 5.

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

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

There are no annotations, so the description carries the full burden. 'Validate' suggests a read-only check, and 'no compose' is a useful behavioral disclosure that prevents the agent from expecting composition side effects. Still, the description does not disclose what happens on validation failure, whether the tool returns a structured report, or whether any state is modified, leaving notable behavioral gaps.

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

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

The description is a single, front-loaded sentence that states the core action, target resource, and validation criteria without any filler. Every word earns its place, and the 'no compose' caveat is packed in efficiently. This is an ideal length for a simple one-parameter validation 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?

For a tool with one parameter and low complexity, the description says enough to select and invoke it, but it omits return behavior entirely. Since there is no output schema, the agent cannot know whether the tool reports success/failure, outputs a detailed report, or throws an exception. The absence of this information is a real gap for a validation tool, though the tool is otherwise simple.

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. The description adds little beyond the schema: it says the file must be 'existing', which slightly clarifies permissibility, and hints at the kind of file (design-contract.json), but it does not elaborate on path format, validation behavior, or output. The parameter semantics remain essentially as documented 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 uses the specific verb 'Validate' against a clearly identified resource ('existing design-contract.json') and names the acceptance-tests catalogue and schema as validation criteria. The 'no compose' clause helps differentiate it from a possible create/compose workflow. This is unambiguous and distinguishes the tool from likely siblings.

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

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

The phrase 'existing design-contract.json' implies it should be used for pre-existing contracts rather than creating new ones, and 'no compose' tells the agent this tool will not run a compose step. However, it does not explicitly name any alternative sibling or state when to choose this tool over wave_design_contract, wave_design_extract, or wave_design_measure. Usage is implied, not 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?

With no annotations provided, the description carries the full transparency burden. It clearly discloses the main behavior (full extraction pipeline) and the return value (manifest.json with files, sha256s, owed), but it omits side effects such as writing the extract directory or the potential season-delta.json output, and gives no indication of whether extraction is non-destructive.

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

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

The description is a single dense sentence that front-loads the action and resource, lists the extracted components, and states the return value. There is no filler or duplication 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?

The description plus the schema covers the main action, required input, optional parameters, and return value, which is enough for a basic invocation. However, the lack of usage context relative to sibling design tools and the under-disclosed file-writing side effects leave noticeable gaps.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description adds no new parameter semantics, but it names the underlying package and pipeline, so it neither improves nor conflicts with the schema.

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

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

The description names a concrete action ('Run ... extraction pipeline') on a specific resource (a .pen board) and enumerates what the pipeline produces: plates/tokens/geometry/copy/components/receipts/frames/manifest. This makes the tool's purpose reasonably distinct from the design-contract/measure siblings, though it does not explicitly contrast itself 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?

There is no guidance on when to use this tool versus sibling tools such as wave_design_contract, wave_design_measure, or wave_design_contract_check. The description implies the input is a .pen board but does not state intended use cases, prerequisites, or exclusions that would help an agent decide between alternatives.

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

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

With no annotations, the description carries the transparency burden and does a good job: it discloses the external package/command, conditional geometry masking, plate rasterization, optional cropping, and the return payload. It does not explicitly confirm a read-only/no-side-effect profile, but the wording 'measure' and 'Returns the measurement JSON' strongly imply a non-mutating analysis 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?

One dense sentence conveys the core command, input options, preprocessing behavior, and output. There is no filler or redundancy; the content is front-loaded and every phrase 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?

The description plus schema covers all parameters and, because there is no output schema, it helpfully lists the returned JSON categories. It could be slightly more complete by explicitly stating that at least one of image/plate must be supplied and what happens if both are given, but the overall picture is sufficient for normal invocation.

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

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

Schema coverage is 100%, so the schema already fully documents all four parameters. The description adds a high-level view of how the parameters combine (image/plate alternative, geometry masking, crop region) but does not add new syntax or formats beyond the schema.

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

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

The description states a specific action ('Run @wave-av/loc-study's measure') and the target resource (image or plate SVG), and it names the result ('measurement JSON (bokashi/keyblock/palette/composition)'). It is clear and not tautological, but it does not explicitly contrast itself with sibling tools such as wave_design_extract or wave_design_contract.

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 when to use the tool: whenever a measurement JSON from an image or plate is needed, with options for cropping and geometry masking. It does not provide explicit when-not-to-use guidance or distinguish this tool from wave_design_extract or wave_design_contract, so usage is left mostly to inference.

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

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

With no annotations, the description carries the burden of conveying behavior. It communicates that this is a read-only GET operation returning a current snapshot, which is transparent for a simple health-check tool. It does not mention potential errors, permissions, or latency characteristics, but those are less critical for a read-only status endpoint.

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 entire description is one compact, front-loaded sentence. It states the action, the resource, the endpoint, and the key response fields without any filler or repetition, making it easy 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?

For a single-parameter read-only tool with no output schema, the description adequately covers what the tool returns by listing connection state, viewer count, and quality indicators. It could add explicit notes about read-only behavior or error cases, but the endpoint, parameter, and response contents are sufficiently clear for an agent to use 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 stream_id property is already documented as 'The UUID of the stream to check.' The tool description adds no additional meaning about the parameter, so the baseline score of 3 is appropriate because the schema already handles parameter semantics.

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

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

The description clearly identifies a GET operation on a stream status resource and lists the returned contents (connection state, viewer count, quality indicators). It does not explicitly name or differentiate sibling tools like wave_get_stream_metrics or wave_get_viewers, but the 'status document' framing plus endpoint path makes the purpose distinct enough.

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 'Get the current status document' implies this tool is for checking a stream's live health, which is a clear context. However, there is no explicit guidance on when to prefer this over wave_get_stream_metrics, wave_get_viewers, or wave_list_streams, nor any exclusions or alternatives mentioned.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explicitly discloses the HTTP method GET (a read-only operation), the specific endpoint, and the return content domains (views, watch time, geographic/device breakdown over a date range). It does not mention default date-range behavior or pagination, but this is a relatively lightweight analytics read.

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

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

The description is a single sentence with no filler, front-loading the action and scope before enumerating the returned metrics and the optional date range. Every element contributes useful information.

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

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

For a 3-parameter tool with a fully documented schema and no output schema, the description is largely complete: it explains the resource, the metrics returned, and the optional date filter. Minor gaps such as the default time window when from/to are omitted are not addressed, but nothing essential to selecting the tool is missing.

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

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

Schema description coverage is 100%, so each parameter is already documented (stream_id UUID, optional from/to ISO 8601 timestamps). The description adds only the phrase 'optional date range', which restates the schema's notion of the from/to parameters rather than adding new semantic detail.

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

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

The description states a clear action ('Get analytics') and a specific resource ('a single stream'), reinforced by the endpoint GET /v1/streams/{id}/analytics and the listed metrics. It is distinguishable from broader tools like wave_list_streams, though it does not explicitly contrast with sibling analytics tools such as wave_get_viewers or wave_get_usage.

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 scope 'for a single stream' and 'optional date range' imply when this tool is appropriate, and the metrics listed (views, watch time, breakdown) indicate the data domain. There is no explicit guidance on when to prefer an alternative tool or when this tool is not appropriate, so usage direction remains 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?

The description states 'GET' and 'Get', which implies a read-only, non-mutating operation. However, with no annotations provided, it does not disclose authentication requirements, possible absence of a billing account, or error behavior, so the behavioral transparency is only partially covered.

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

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

A single, well-structured sentence that leads with the action and resource, then gives the endpoint and expected data. Every element is useful and there is no 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?

For a zero-parameter read-only tool with no output schema, the description adequately conveys what the call returns. It could be more complete by noting whether the billing account may be absent or require setup, but for simple invocation context it is largely 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?

The tool has zero parameters and the schema is empty, so there is nothing to document. The description adds value by indicating the fields the response contains, helping the agent understand what the tool returns.

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

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

The description names a specific verb and resource ('Get the current billing account') and enumerates what it returns: plan, Stripe customer status, and subscription state. This clearly separates it from siblings like wave_get_usage or wave_get_viewers, which cover different domains.

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 makes the use case clear: an agent should call this tool when it needs billing or subscription details for the current account. It does not explicitly exclude alternative tools, but the billing-specific resource and returned fields make the appropriate context evident.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It reveals the HTTP GET method, implying a read-only operation, and mentions the default current-month behavior. However, it does not describe authentication needs, response contents, timezone handling, or whether the usage data is aggregated or itemized.

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 that names the operation, resource, endpoint, and default behavior without any wasted words. It is immediately scannable and easy to parse.

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

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

For a simple read-only tool with two optional and fully documented parameters, the description is largely sufficient. The only gap is that there is no output schema and the description does not clarify what the response looks like, but this does not block correct invocation.

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

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

Schema description coverage is 100%, with both `from` and `to` documented including defaults and date format. The description's 'defaulting to the current month' restates what the schema already says, adding no new parameter semantics beyond the endpoint context.

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 clearly identifies the operation as retrieving billed usage for a date range, with a specific endpoint and a default behavior. It distinguishes itself from siblings like wave_get_subscription and wave_get_viewers by naming a unique billing resource.

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 clear context for when to use this tool: when billed usage data for a date range is needed, and it notes that omitting dates defaults to the current month. It does not explicitly name alternatives or exclusion conditions, but no sibling is a direct substitute.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the HTTP method GET, which indicates a read-only operation, and the date-range filtering behavior. However, it does not mention authentication, rate limits, pagination, or the shape of the response, leaving notable operational details unstated.

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

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

The entire description is one tight sentence that leads with the action, specifies scope, includes the endpoint, and notes the optional date range. Every word provides value and there is no redundancy or filler.

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

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

For a simple read-only tool with two optional, fully documented parameters, the description is largely sufficient: it states exactly what is retrieved and the available filter. The lack of an output schema means the response structure is not described, which prevents a 5, but the core invocation details are 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 the baseline is 3. The description's 'optional date range' adds minimal grouping context for from/to, but the schema already documents the parameters and their optionality. There is no deeper semantic information 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?

The description states a specific verb ('Get'), resource ('viewer engagement analytics'), and scope ('account-wide'), and even includes the endpoint (GET /v1/analytics/engagement). It is clear and distinct from sibling tools like wave_get_stream_metrics, but does not explicitly name or differentiate a sibling, so it falls short of a 5.

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

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

The phrase 'account-wide' implies when this tool should be used versus per-stream alternatives, and 'optional date range' hints at parameter usage. However, there is no explicit guidance about when to prefer this over siblings like wave_get_usage or wave_get_stream_metrics, no exclusions, and no mention of prerequisites.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it only reveals that this is a GET (read) operation scoped to the account. It does not disclose pagination behavior, ordering, authentication needs, or what happens with empty results.

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

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

A single front-loaded sentence delivers the verb, resource, and scope with zero filler. The API endpoint inclusion is a useful bonus that does not bloat the text.

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

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

For a simple list tool with fully documented optional parameters, the definition is functional, but with no output schema and no annotations, the description leaves the agent without expectations about the response shape or how this tool fits into the production lifecycle. Acceptable yet incomplete.

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% — all three parameters (limit, offset, status) are already documented with types, ranges, defaults, and the status enum. The description adds no parameter-level meaning, 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 states a specific verb ('List'), a specific resource ('multi-camera productions'), and a scope ('in your WAVE account'), plus the API endpoint. The resource type clearly distinguishes it from siblings like wave_list_streams and wave_create_production.

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

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

No guidance is given about when to use this tool versus alternatives such as wave_list_streams or wave_create_production. The tool name implies listing productions, but no exclusions, prerequisites, or selection conditions are 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?

With no annotations, the description carries the full burden. It discloses that this is a GET endpoint, implying a read-only operation, and mentions pagination and status filtering. However, it does not disclose response shape, ordering, authentication needs, rate limits, or any other behavioral details beyond the endpoint.

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 contains the core purpose and the API endpoint, then the supporting modifiers (pagination, status filtering). Every part is useful and nothing is redundant.

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

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

For a simple read-only list tool with no required parameters and fully documented parameters, the description is largely complete. It does not describe the return payload since no output schema exists, but the basic purpose and filtering behavior are enough for an agent to select and 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?

The input schema already has 100% description coverage for all three parameters (limit, offset, status). The description's mention of 'pagination and status filtering' adds no meaning beyond what the schema already provides, so the baseline score 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 clearly states the action ('List streams'), the resource ('streams in your WAVE account'), and the exact API endpoint (GET /v1/streams). This is specific enough to distinguish it from sibling tools like wave_list_productions or wave_get_stream_health.

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 when to use it: whenever an agent needs to list streams in the WAVE account. However, it does not explicitly contrast it with alternatives, mention when not to use it, or note exclusions such as listings scoped to productions or other resources.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It does reveal that this is a POST request and marks a highlight, but it does not mention side effects, reversibility, auth requirements, idempotency, whether multiple highlights per stream are allowed, or what the API returns. This is a meaningful transparency gap for a mutating tool.

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

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

The description is a single efficient sentence that states the action, resource, purpose, and endpoint with no filler or redundancy. All content is relevant and front-loaded, making it 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?

The input schema fully documents the parameters, and the description provides the core action and endpoint. However, with no output schema and no annotations, the description does not clarify expected return values, failure modes, or how this relates to the wave_create_clip workflow. It is adequate for basic invocation but leaves uncertainty around post-invocation behavior.

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

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

All five parameters already have descriptive definitions in the input schema (100% coverage), including stream_id, timestamp, label, confidence, and duration_seconds. The description itself adds no parameter-level meaning beyond the endpoint path variable corresponding to stream_id, so the schema carries the load and a baseline score 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 action ('Mark'), a specific resource ('a moment in a stream'), and a clear purpose ('as a highlight for later clipping'). It also includes the exact POST endpoint, which makes the tool's function unambiguous and distinguishes it from the sibling wave_create_clip by indicating this only marks for later clipping rather than creating a clip directly.

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

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

The phrase 'for later clipping' implies this tool is used to save a marker before a clip is created, but there is no explicit statement of when to use it versus alternatives such as wave_create_clip. No exclusions, prerequisites, or direct references to sibling tools are provided.

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

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

With no annotations, the description must carry the full behavioral burden, but it only states that messages can be blocked, flagged, or allowed. It does not disclose whether actions are reversible, whether permission is required, what side effects occur, or what response the caller receives.

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 one efficient sentence that front-loads the core action, then provides the endpoint and the three possible actions. Every element 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?

This is a mutating tool with no output schema and no annotations, but the description stops at the action itself. It omits the result of the call, error/edge-case behavior, and the consequence of each moderation action, leaving the agent under-informed about what happens after invocation.

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

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

Schema coverage is 100%, so the parameters are already documented. The description's 'block, flag, or allow' phrase adds no new meaning beyond the action enum, but it does helpfully summarize the only non-obvious parameter.

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

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

The description uses a specific verb ('Moderate'), names the resource ('chat message in a live stream'), and enumerates the allowed outcomes ('block, flag, or allow'). It also includes the endpoint, making the tool's role unambiguous relative to the long sibling list.

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

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

The context is clear: use when a live-stream chat message needs a moderation decision. It doesn't explicitly name when not to use it or point to alternatives, but no sibling tool obviously overlaps, so the lack of exclusions is not a notable gap.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose that this is a state-changing operation (show/hide) and includes the POST method, which is useful. However, it does not mention side effects, prerequisites, idempotency, or error behavior, which would be valuable for a mutation tool.

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

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

The description is a single sentence that front-loads the core action and context, and includes the endpoint without any filler. Every part earns its place.

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

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

For a simple three-parameter mutation tool with complete schema descriptions, the description is largely sufficient to invoke the tool correctly. It could optionally mention the response or prerequisites, but the absence of an output schema and the simplicity of the operation make those gaps minor.

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

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

The input schema already covers 100% of parameters with meaningful descriptions, so the baseline is 3. The description adds no additional parameter-level detail beyond what the schema provides, other than implied linkage through the endpoint path.

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 clearly states the action ('Show or hide'), the resource ('graphics overlay'), and the context ('in a production'), and reinforces it with the exact endpoint. This is specific enough to distinguish the tool from siblings focused on design, streaming, camera control, or production management.

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 when to use the tool—whenever overlay visibility needs to be changed—but it does not explicitly state when not to use it or mention alternatives. The context is clear, but there is no explicit routing guidance relative to other tools.

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

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

With no annotations, the description carries the behavioral burden, and it does so well: it discloses the one-shot nature, the non-persistent behavior, the endpoint/multipart detail, and the 404 meaning when the feature is not armed. It does not mention response format or potential side effects like usage costs, but the core behavioral traits are disclosed.

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

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

Two sentences, no filler. The main purpose is front-loaded, the scope constraint and non-persistent clarification come immediately after, and the operational prerequisite/error semantic is compactly appended.

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

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

For a 10-parameter tool with no annotations and no output schema, the description covers the key operational constraints: single chunk, non-persistent feed, feature prerequisite, and 404 diagnosis. It is complete enough to guide selection and invocation, though it omits explicit return-value expectations and sibling comparisons.

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 10 parameters. The description adds context by framing the call as processing one audio chunk and running a fast-LLM step, which helps with audio_base64 and llm_model, but it does not go beyond that 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?

The description states a specific verb ('Transcribe') and resource ('an audio clip') and immediately clarifies the optional fast-LLM step over the transcript. It also distinguishes itself from a persistent caption feed, which is important given the 'captions' name and sibling streaming tools.

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

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

The description gives clear context: it processes exactly ONE provided audio chunk and explicitly says it does not attach a persistent caption feed, so an agent knows not to use it for ongoing live-stream captioning. It also provides a prerequisite (live pipeline feature enabled) and explains the 404 failure mode, but it does not name specific alternative sibling tools.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It only states the operation and endpoint but does not disclose preconditions, side effects, whether the stream must be in a stopped state, error behaviors, or if the operation is idempotent. For a state-changing action, this is a notable gap.

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

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

The description is a single, directly relevant sentence that front-loads the action and includes the API path. Every word earns its place, and there is no superfluous 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?

Given the tool's low complexity (one well-documented parameter, no output schema, no annotations), the description is minimally adequate for selecting and invoking the tool. However, it omits behavioral context such as the stream's required state before starting and what a successful start means, which an agent would benefit from knowing.

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

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

The schema already documents the single parameter with a full description, format, and pattern. The tool description adds no additional semantic meaning beyond the endpoint context, so the baseline of 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 clearly states the action ('Start a stream') and the resource ('by its ID'), and includes the exact HTTP endpoint for precision. This distinguishes it from sibling tools such as wave_stop_stream, wave_create_stream, and wave_list_streams without needing to open schemas.

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 action to use this tool is implied by the name and description: call it when you want to start an existing stream. However, there is no explicit guidance about when not to use it, nor any reference to alternatives like wave_create_stream for new streams or wave_stop_stream for stopping.

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

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

With no annotations, the description carries the full burden, but it only states the action and endpoint. It does not disclose whether stopping is idempotent, what happens to the stream's state, whether the operation can be reversed by starting again, or what errors occur for an unknown or already-stopped stream.

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 definition is a single front-loaded sentence that states the verb, object, and endpoint with no filler. It is appropriately sized for a one-parameter 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?

For a simple one-parameter tool, the core action and parameter are covered, but the lack of annotations, no output schema, and no behavioral notes leave gaps around expected results and error semantics. The description is minimal but not grossly insufficient for a straightforward stop operation.

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

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

Schema description coverage is 100%; the schema already names stream_id as 'The UUID of the stream to stop' with format and pattern constraints. The description adds only the 'active' qualifier, which is marginal context, 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 uses a specific verb 'Stop' with a clear resource ('an active stream') and the required identifier, and adds the exact HTTP endpoint. It is clearly distinct from siblings like wave_start_stream or wave_list_streams by action, though it does not explicitly name an alternative.

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

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

The word 'active' implies this is only applicable to currently running streams, and the stop action itself indicates when it is needed. However, there is no explicit guidance about when not to use it, how to confirm a stream is active, or which sibling alternatives might be relevant.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Switch' and gives the endpoint, without describing side effects, immediacy of the switch, permission requirements, reversibility, or how transitions actually behave. This is a significant gap for a state-changing operation.

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

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

The description is a single, front-loaded sentence with no filler. The parenthetical endpoint adds orientation, and every part of the text earns its place.

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

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

With no annotations, no output schema, and a state-changing operation, the description should provide more context about response behavior, side effects, and when to prefer this over sibling tools. The schema covers parameters well, but the definition as a whole is not contextually complete for an agent to confidently invoke it in all appropriate situations.

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 each parameter already explained in the input schema. The description adds no additional parameter-level meaning beyond naming the operation, 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 clearly states the action ('Switch'), the resource ('program or preview bus'), and the target ('camera index') in a multi-camera production. It is specific enough to differentiate from broader siblings like wave_control_camera, though it does not explicitly name or contrast siblings.

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

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

There is no guidance on when to use this tool versus alternatives such as wave_control_camera, nor any prerequisites or exclusions. The phrase 'in a multi-camera production' implies some context, but does not help an agent decide between this and related camera-control tools.

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

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

With no annotations, the description carries the full disclosure burden, and it does this well by stating the input format, the output format, the side effect of binding the agent to a room, and the headless execution model. It does not mention file overwrites, auth requirements, or blocking/timeout behavior, but the core behavioral contract is clear.

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

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

Two dense sentences carry all essential information with no filler. The main behavior is front-loaded, followed by the format details, and the closing 'No browser, no WebRTC' crisply sets expectations.

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 3-parameter tool with no output schema, the description covers the inputs, the output destination, and the environment constraint. It does not explain return semantics, error conditions, or whether the call blocks until the reply is ready, but the primary contractual details an agent needs to invoke it are present.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value by specifying the exact audio formats: 16-bit LE 48 kHz PCM input (mono or stereo) and raw 16-bit LE 48 kHz stereo PCM output. This goes beyond the terse schema descriptions and helps an agent prepare correct inputs and interpret the output.

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

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

The description uses a specific verb ('Drive') and names a concrete resource (the WAVE voice agent), then spells out the exact flow: bind to a room, send a caller WAV, receive a spoken reply PCM. This clearly distinguishes it from the sibling tools, none of which describe audio-in/audio-out headless conversation.

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 clearly establishes the context: use this for a headless conversation with the WAVE voice agent, with 'No browser, no WebRTC' as an explicit boundary. It does not name alternative sibling tools or say when not to use it, but the context is specific enough to guide selection.

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