BeatDesign

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

Annotations already state destructiveHint false; the description adds that it returns a PNG frame and gives position guidance, but does not disclose additional side effects or error behavior.

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

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

Single sentence, direct and free of unnecessary detail.

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

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

Provides enough context to know it extracts frames from video assets, but lacks mention of return format details and edge cases; however, the schema covers required parameters.

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

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

Schema coverage is 0%; only the position parameter receives a hint about using 'last' for tail-frame continuation. assetId and projectId are not explained.

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 tool extracts a PNG frame from a project video asset, with a specific verb and resource, and distinguishes it from other asset and editor 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?

It provides a hint to use position 'last' for tail-frame continuation, but does not explicitly compare with alternative tools like bdesign_asset_get or bdesign_canvas_continue_from_tail.

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 readOnlyHint annotation already establishes safety, and the description's 'Read' confirms no mutation. However, the description adds little beyond that, such as failure behavior or scoping effects of projectId.

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 concise sentence that communicates the core operation without extraneous detail. Well structured 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?

Adequate for a simple read operation, but incomplete regarding projectId semantics and how it interacts with assetId. No output schema is present, yet the description does not describe expected results or error cases.

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

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

The description mentions assetId implicitly but does not clarify its format or uniqueness, and projectId is entirely unexplained. With no schema descriptions, coverage is low and the description does not compensate.

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'), a specific resource ('one project Asset'), and the key identifier ('stable assetId'). Clearly distinguishes a single-asset fetch from list/import operations.

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

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

No explicit guidance on when to use this tool versus alternatives like bdesign_asset_list or bdesign_asset_import. The singular 'one' implies direct fetch by ID, but no when-not-to-use or alternative comparison is provided.

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

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

Annotations indicate idempotentHint=false and destructiveHint=false, but the description adds no additional behavioral details such as whether importing the same file twice creates duplicates, whether it overwrites existing assets, or what side effects occur on the asset library. The description relies on implied 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, concise sentence with no redundant information. It directly states the purpose and the required parameter type, making it 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?

The tool is a straightforward import action, but the description does not mention what the function returns (e.g., asset ID, success status) or any potential errors (e.g., invalid path, unsupported format). Without an output schema, this missing context leaves users uncertain about the outcome.

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 description clarifies that filePath is an absolute path, which adds meaning. However, projectId is not explained at all despite being an optional parameter. With 0% schema description coverage, the description only partially compensates by addressing one of two parameters.

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 (import), the resource (project Asset library), and the input type (local image, video, or audio file). It distinguishes itself from sibling tools like asset_list and asset_get by focusing on adding a new asset.

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 context (import from absolute path) but does not explicitly mention when to use this tool versus alternatives like asset_list or asset_extract_frame. It implies usage for adding assets but lacks direct guidance on when not to use 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?

An annotation readOnlyHint: true already signals safety; description adds that it lists assets belonging to a project, with no contradictory side-effect language.

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 concise sentence with no unnecessary detail 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?

Adequate for a simple listing tool, but it omits parameter purposes, requiredness, and output shape; no output schema is provided to fill the gap.

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

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

Schema description coverage is 0%, so description must compensate; it does not explain projectId or limit beyond what the property names imply.

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 verb 'List', resource 'Assets', and scope 'project'; clearly distinct from sibling tools like get, import, and extract_frame.

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 verb 'List' implies enumeration use case, but it does not explicitly contrast with asset_get, asset_import, or other 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?

The description explains incremental behavior and place_card semantics, but relies on annotations for idempotency and destructive hints. It does not describe what happens on failure, revision mismatches, or partial application, though annotations cover the basic safety profile.

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 concise, containing only two focused sentences without redundant information or unnecessary detail. It is well-structured 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?

The description is far too sparse for the tool's complexity: no output schema, no parameter explanations, no error handling context, and no mention of how operations are committed or validated. It covers only one narrow usage scenario (place_card) and leaves most operational context unexplained.

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

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

The schema has 0% description coverage and the description does not explain any parameters such as commandId, projectId, operations, idempotencyKey, or expectedRevision. Given the large and complex operations schema, this is a significant gap.

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

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

The description clearly states the tool applies incremental Canvas operations and distinguishes it from raw document replacement, which is not exposed. It also provides a concrete example (place_card) that clarifies its purpose relative to similar canvas 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?

It gives explicit guidance for when to use place_card (newly connected nodes) and explains that later user drag positions remain untouched unless place_card is called again. It does not explicitly name sibling tools for alternatives, but the context is reasonably clear.

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

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

Annotations declare idempotentHint and destructiveHint, but the description does not disclose any side effects, whether it mutates canvas state, or how destructive behavior manifests. It only says 'create', which could imply modification but without explicit warning.

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 that packs the entire workflow into one line without unnecessary words or repetition. It is highly concise and well-structured.

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

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

With 9 parameters, 0% schema description coverage, and no output schema, the description leaves out nearly all necessary context. It does not specify required vs optional fields, the meaning of projectId/assetId/commandId, or what the tool returns aside from an implicit reference. It is far from complete for a tool of this complexity.

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

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

The schema provides zero descriptions for any of the 9 parameters, and the description does not explain any parameter names or their roles. Only a conceptual 'first_frame' reference is mentioned, not mapped to actual schema fields. There is no compensation for the absence of parameter docs.

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 specific actions: extract the tail frame, place it on Canvas, create a continuation node, and call bdesign_generation_submit. It is action-oriented and distinct enough, though it does not explicitly name a sibling 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?

It provides a sequential workflow and mentions calling another tool, but does not specify when this tool should be chosen over alternatives like bdesign_canvas_apply or bdesign_asset_extract_frame. No comparison 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?

The description is consistent with the readOnlyHint annotation and does not contradict it. However, it adds no behavioral details beyond what the annotation already provides, such as side effects or constraints.

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

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

The description is a single concise sentence that directly states the tool's purpose. It is well-structured and front-loaded with the key action and resource.

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

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

For a simple read operation with a single parameter, the description is minimally sufficient. However, because there is no output schema, the description could more explicitly state what is returned beyond 'document and revision'.

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

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

The schema provides no description for projectId, and the tool description does not explain the parameter. With 0% schema description coverage and no compensation in the description, parameter semantics are entirely missing.

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 specific action ('Read') and the resource ('Canvas document and revision for a project'). It is understandable and provides enough purpose, though it does not explicitly differentiate from the similarly named canvas_view sibling.

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 like canvas_view or canvas_search. The description implies retrieval but does not state context or exclusions.

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

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

The readOnlyHint annotation already covers the non-destructive nature. The description adds that it searches by specified fields but discloses no other behavioral details such as result limits, ordering, pagination, or whether it searches all projects or just one. With the annotation present, the safety aspect is transparent; only additional runtime behavior is missing.

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

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

The description is a single, concise sentence with no redundant wording. It conveys the core purpose and search criteria efficiently.

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

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

The description tells agents what the tool does and what can be searched, but it does not describe the return value or output shape. Given the absence of an output schema, this omission leaves some ambiguity about whether the result is a list, a count, or id-only matches. It is adequate for a simple search tool but not fully complete.

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

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

The description clarifies the meaning of 'query' by listing name, prompt, result text, and model, and maps 'kind' and 'type' to node categories and media types. However, projectId is not mentioned at all, and there is no explicit field-to-parameter mapping. The enum values for kind and type already provide some semantics, but the description does not fully cover all parameters.

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 specific verb ('Search') and object ('Canvas nodes') and enumerates the search dimensions (name, prompt, result text, model, kind, media type). It distinguishes itself from sibling tools like canvas_get and asset_list by focusing on searching Canvas nodes, though it does not explicitly name sibling 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?

No explicit guidance is provided for when to use this tool versus alternatives such as canvas_get, canvas_view, or asset_list. The phrase 'Search Canvas nodes' implies a retrieval use case, but there is no stated condition like 'use when you need to find nodes matching criteria' or 'use instead of listing all 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 declare readOnlyHint and idempotentHint, and the description does not contradict them. The description adds output context ('current Canvas revision and focused card summary') but does not disclose any additional behavioral traits 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?

The description is a single, front-loaded sentence with no filler. It leads with the main action and then adds the optional modifier and output components efficiently.

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

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

With no output schema, the description does list the main return elements (browser handoff, current revision, focused card summary), but it leaves projectId semantics unexplained and provides no context for how this view relates to other canvas/editor tools. It is adequate but not rich.

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

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

The input schema has no parameter descriptions (0% coverage), and the description only partially clarifies cardId via 'optionally focused on one card'. projectId is not explained at all, so the description does not fully compensate for the missing schema documentation.

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

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

The description clearly states the tool returns a Canvas browser handoff and identifies optional card focus plus revision and card summary outputs. It does not explicitly differentiate from sibling tools like bdesign_canvas_get or bdesign_editor_view, but the specific 'browser handoff' resource makes the purpose 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 guidance is given about when to use this tool versus siblings such as bdesign_canvas_get, bdesign_canvas_search, or bdesign_editor_view. The description only states what is returned, not the intended selection context.

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 readOnlyHint annotation already covers the safety profile, and the description's 'Diagnose' wording is consistent with it — no contradiction. The description adds context on what checks are performed (gaps, overlaps, missing media, etc.) but says nothing about the return format, whether it produces a report, or what happens when no issues are found. With the annotation carrying the read-only signal, 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?

The description is a single front-loaded sentence that wastes no words, leading with the verb and listing the diagnostic targets compactly. It earns a 4 rather than 5 only because it could convey a bit more (such as output shape) without adding bulk.

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, single-parameter diagnostics tool this is mostly complete: the checks are enumerated and the annotation covers safety. However, with no output schema, the description should say what the tool returns (a report, a list of issues, etc.), and that is missing. Required parameters showing 0 with a projectId present is also mildly ambiguous, though likely a schema artifact.

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

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

Schema description coverage is 0%, so the description should compensate, but there is only a single self-explanatory parameter, projectId. The parameter's meaning (the project to diagnose) is obvious from its name and the tool's purpose, so the description adds little beyond what the schema implies. The description adds no syntax or formatting details, which is acceptable for a single trivially-clear ID 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 ('Diagnose') and lists concrete targets: gaps, overlaps, missing media, duration mismatches, and tiny clips. This clearly states what the tool does and naturally distinguishes it from siblings like bdesign_editor_view or bdesign_editor_get, none of which claim diagnostic scope. It stops short of 5 because it doesn't explicitly name what it is not or reference the project context.

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. Nothing states that it should be used before editing to validate a project, or when to prefer it over bdesign_editor_view or bdesign_canvas_get. No exclusions or conditions are provided, so an agent must infer the appropriate call context.

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 idempotentHint=true and destructiveHint=true, which cover retry safety and destructive potential. The description adds no additional behavioral context, such as atomicity of the operation batch, failure behavior, or the effect of expectedRevision. Since annotations already cover the core safety profile, a 3 is appropriate—the description neither contradicts nor enriches the behavioral picture.

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

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

The description is a single, focused sentence that front-loads the core purpose ('Apply incremental timeline operations') and then enumerates examples. It is concise and easy to scan, with no filler or redundancy. A slightly more explicit enumeration of operation types would improve it, but it remains efficient.

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

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

This is a complex tool with 5 parameters and a deeply nested operations array containing 17 distinct operation variants. The description gives only a high-level list and omits critical context: the exact operation types, required fields per type, semantics of each operation, error handling, and the role of expectedRevision. Without an output schema, the description leaves an agent under-equipped to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It lists some operation type names (e.g., 'add', 'trim', 'split') but does not explain the structure of the operations array, the required fields per operation type, or the meaning of top-level parameters like commandId, projectId, idempotencyKey, or expectedRevision. The list of operations is a hint but not sufficient for an agent to construct valid calls.

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 tool applies incremental timeline operations and lists a broad range of operation types (media add/update, trim, split, move, remove, audio, Takes, captions, SRT). This distinguishes it from read-only siblings like view, history, and render, and is not a tautology. However, it uses 'such as' and omits several operation types from the schema (e.g., set_clip_duration, replace_overlay_asset, set_render), so it is not fully precise.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is the primary mutation tool for timeline edits, nor does it direct users to view or snapshot tools for inspection. There is no mention of prerequisites like projectId or when to use specific operation types.

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=true, and the description's 'Read' is consistent with that. It adds the context that the tool returns the timeline and revision, but discloses no other behavioral traits such as project selection behavior or response shape.

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. It is concise, though it omits some contextual details.

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 simple parameter and a readOnly annotation, the description is minimally sufficient, but it lacks any mention of projectId or relationship to sibling read tools. An agent might know what it does but not precisely when to invoke it over alternatives.

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

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

Schema description coverage is 0%, and the description never mentions projectId. The parameter name is self-explanatory, but the description does not compensate for the schema's lack of documentation or clarify the optionality implied by zero required parameters.

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 'Read' and names a concrete resource: 'current Editor timeline and revision.' It is clear what the tool does, though it does not explicitly differentiate itself from sibling tools like bdesign_editor_view or bdesign_editor_history.

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 for when to use this tool instead of siblings such as bdesign_editor_history or bdesign_editor_view. The word 'current' implies a contrast with history, but no explicit when/when-not or alternatives 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?

The description aligns with the readOnlyHint annotation by using 'Read', and adds context by specifying that the receipts are 'persisted' and relate to changes. It does not mention side effects, but for a read-only operation this is sufficient given the annotation already covers safety.

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

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

The description is a single, focused sentence with no redundant words. It conveys the essential action and target clearly, making it 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?

While the core purpose is stated, the description lacks any detail about return format, parameter semantics, or invocation context. Given there is no output schema, the agent has no information about what the result looks like, making it incomplete for practical use.

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

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

The schema provides no descriptions for the parameters, and the description does not explain the meaning of 'limit' or 'projectId'. With 0% schema coverage, the description must compensate, but it does not, leaving the agent to guess whether projectId filters by project and how limit controls the result set.

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 'Read' clearly indicates a retrieval operation, and the resource 'persisted command receipts for timeline and Canvas changes' identifies the specific data being accessed. This distinguishes it from tools like bdesign_editor_render or bdesign_editor_snapshot, though 'command receipts' is slightly specialized terminology.

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 guidance is provided on when to use this tool versus alternatives such as bdesign_generation_history or bdesign_canvas_search. The description implies a historical read but does not contrast with other history/read tools, leaving the agent to infer context from sibling names.

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 indicate destructiveHint=true and idempotentHint=true, so the description should add context about what gets destroyed (e.g., replacing existing captions) or any side effects. The description simply says 'Import' without elaborating on the destructive nature or the replace behavior, which is a significant omission given the annotation.

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 concise, with two sentences that front-load the core purpose and then give an input hint. No fluff or repetition, though it could be slightly more informative without losing brevity.

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 7 parameters, no output schema, and only annotations for safety, the description is inadequate. It fails to explain critical behavioral aspects like the replace default (true), the need for projectId, or how idempotencyKey and expectedRevision work. An agent would have to guess or infer too much to use this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining key parameters. It mentions 'srt' and 'filePath' as the two input modes, but ignores the other five parameters (replace, commandId, projectId, idempotencyKey, expectedRevision). This leaves the agent blind about critical parameters like 'replace' and project scoping.

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

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

The description states the specific verb 'Import', the resource 'SRT captions', and the target 'project timeline caption track', making the tool's function unmistakable. It also clearly distinguishes this from sibling tools like bdesign_editor_edit or bdesign_asset_import by focusing on captions.

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 (import SRT when you have caption content) but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It only offers a brief hint about how to provide the input, which is more parameter-related than usage context.

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 idempotency and destructiveness (both false). The description adds valuable context about the ffmpeg/ffprobe dependency, which is a runtime prerequisite. It does not disclose other important behaviors such as whether the render is synchronous or asynchronous, whether it mutates project assets, or what happens on failure. The added dependency is useful but does not fully close the behavioral 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 two terse sentences. The first defines the core action and output; the second provides a critical dependency. Every word earns its place, with no redundancy or fluff.

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

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

There is no output schema and no enrichment for parameters, so only the basic purpose is declared. For a side-effecting render operation the agent would need to know what a successful call returns (e.g., asset ID), how expectedRevision is used, and error expectations. The description is under-specified for an agent to call the tool reliably.

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?

Input schema has zero parameter descriptions (0% schema coverage), so the tool description must explain the parameters. It does not mention projectId or expectedRevision at all. "Project-owned" only implies projectId, but expectedRevision is left entirely unexplained (likely a concurrency or revision token). The description fails to compensate for the total lack of schema parameter documentation.

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

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

The description states a highly specific verb ("Render") and resource ("authoritative Editor timeline to a project-owned MP4 Asset"), plus concrete output features (overlays, captions, mixed audio). This clearly distinguishes it from siblings like bdesign_editor_view or bdesign_editor_snapshot, which are not rendering final MP4 assets.

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

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

It tells the agent this produces the authoritative MP4 and makes a required runtime dependency explicit (local ffmpeg and ffprobe). However, it does not explicitly say when to use it versus siblings (e.g., final export vs preview/snapshot), nor provide any clear exclusions beyond the ffmpeg requirement.

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 annotation readOnlyHint: true is consistent with the description's claim of 'inspection' and 'not a pixel screenshot,' which implies non-destructive behavior. However, the description does not disclose what data is returned or whether any state changes occur beyond the read-only implication.

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

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

The description is brief but poorly structured. The first sentence is grammatically ambiguous and unclear, while the second provides a useful clarification but does not compensate for the vagueness.

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 lack of an output schema and unclear action, the description omits critical context about what a 'snapshot' entails, what 'resolve timeline clips' means, and what the tool returns. It is incomplete for an agent to reliably invoke it.

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

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

The schema has two parameters (time and projectId) with no descriptions, and the description does not explain their purpose or relationship to the tool's action. Schema coverage is 0%, and the description fails to compensate.

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 it performs 'semantic inspection' and is not a pixel screenshot, but the phrase 'Resolve the active timeline clips at a time' is ambiguous and does not clearly define the tool's action or output. It fails to distinguish from sibling tools like bdesign_editor_view or bdesign_canvas_get.

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. No sibling tools are mentioned, and no use-case guidance is provided.

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

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

The annotation readOnlyHint=true is consistent with the description's 'Return' wording, so there is no contradiction. However, the description adds no extra behavioral context such as potential costs, rate limits, or side effects beyond what the annotation already conveys.

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 no filler or redundancy. It is well-structured and immediately conveys the core purpose.

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

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

There is no output schema, and the description does not explain the structure of the 'browser handoff' or 'semantic snapshot'. Important context about what the caller receives and how to interpret the result 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?

The description ties 'time' to 'timeline time', giving some meaning to that parameter, but 'projectId' is not explained at all. With no parameter descriptions in the schema, the description provides only minimal semantic coverage.

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 tool returns an Editor browser handoff for a given timeline time and includes a semantic snapshot. It distinguishes the action from related editor tools, though 'browser handoff' remains somewhat undefined.

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 editor_render, editor_snapshot, or editor_get. The description does not mention exclusions or preferred scenarios.

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 annotation readOnlyHint: true already covers the read-only nature. The description adds no additional behavioral detail (e.g., default limit, ordering, or whether it returns all history or recent only). Since no extra context is provided beyond the annotation, the score is low.

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

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

The description is a single clear sentence with no redundant words. It immediately conveys the core functionality without unnecessary elaboration, making it highly efficient 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?

There is no output schema, so the description should compensate by explaining what the response contains, pagination, or default behavior. It does none of these. The description is minimal and lacks essential context such as whether the history is ordered, the meaning of 'limit', or any filter options, leaving significant gaps.

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

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

Schema description coverage is 0%. The description does not explain the purpose of the 'limit' parameter and only vaguely implies 'projectId' via 'for a project'. With no parameter descriptions and no compensation in the tool description, the agent has insufficient information to correctly populate parameters.

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) and the resource (generation history) with a scoping qualifier (for a project). This distinguishes it from sibling tools like bdesign_generation_status (which checks a single generation) and bdesign_generation_submit (which creates a generation), making the purpose 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 provides no guidance on when to use this tool versus alternatives such as bdesign_generation_status or bdesign_generation_models. There is no mention of conditions, use cases, or differentiators, leaving the agent without context for tool selection.

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 aligns with the readOnlyHint annotation by stating 'Read', so there is no contradiction. It adds the detail that the response includes 'defaults and accepted parameters', which provides useful context about the return content. However, it does not disclose any other behavioral traits such as error handling, required permissions, or response format, though the annotation already covers the safety profile.

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

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

The description is a single concise sentence, front-loading the action and resource. It contains no unnecessary words. It is appropriately sized for the simplicity of the tool, though it could be slightly more informative without becoming verbose.

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

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

Given the tool has only one parameter and no output schema, the description should at least clarify what the parameter represents and what the response looks like. It mentions 'defaults and accepted parameters' as part of the return, but does not explain the parameter or provide any usage context. An agent cannot fully understand how to call this tool correctly without additional inference.

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 a single parameter 'modelId' with no description (coverage 0%). The description does not explicitly explain that modelId is the identifier for the logical model. It says 'one logical model' but does not connect it to the parameter. This forces the agent to infer that modelId is the model's ID, which is not explicitly stated. Since coverage is 0%, the description should compensate but fails to do so.

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

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

The description states a clear verb ('Read') and a specific resource ('one logical model'), and mentions what is included ('defaults and accepted parameters'). This distinguishes it from sibling tools like bdesign_generation_models (which likely lists models) by the singular 'one'. However, it does not explicitly name the alternative or differentiate beyond that.

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 for retrieving a single model but provides no explicit guidance on when to use this versus listing tools or other siblings. No conditions or exclusions are mentioned. The phrase 'one logical model' suggests it is for a specific model, but there is no direct statement of when not to use 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?

The readOnlyHint annotation already indicates this is a read operation. The description ('List') is consistent with that and adds no additional behavioral context such as pagination, rate limits, or side effects, which is acceptable given the annotation coverage.

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

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

The description is a single concise sentence with no unnecessary words. It directly states the purpose and scope without redundancy, making it efficiently structured.

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

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

For a list operation with no output schema, the description is complete enough. It conveys the action and the type of data returned. The lack of an output schema is not an issue here, and the description sufficiently covers the tool's purpose.

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

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

The single parameter 'kind' is fully defined by its enum values (image, video, analysis) in the schema, so the schema coverage is 100%. The description does not add extra meaning to this parameter, remaining at the baseline 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 the action ('List') and the resource ('generation models'), and adds detail about the content ('current parameter/reference capabilities'). It distinguishes itself from the sibling tool bdesign_generation_model_get by implying a plural listing.

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 guidance is provided on when to use this tool versus alternatives like bdesign_generation_model_get. The usage is only implied by the verb 'List' and the context of sibling tools, but no direct when/when-not or alternative comparisons are given.

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

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

The readOnlyHint annotation already communicates that this is a read-only operation, so the description does not need to repeat that. However, the phrase 'when possible, refresh' introduces ambiguity about what refresh means (e.g., triggering a regeneration vs. refreshing local status), and no additional side effects or limitations 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?

The description is a single, tight sentence that conveys the core functionality without unnecessary words. It is well-structured and front-loaded with the primary action.

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, but the description omits important details such as what 'refresh' does, how projectId affects the operation, and what the response looks like. It is not complete enough for an agent to know expected behavior without consulting other documentation.

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 no descriptions for any parameters, and the tool description offers no explanation of generationId, projectId, or refresh. Parameter meanings are left entirely to inference from their names, which is insufficient for unambiguous use.

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 (read and optionally refresh) and the target resource (one generation task). It is specific enough to distinguish from sibling tools like generation_history which operate on multiple tasks, 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?

No guidance is provided about when to use this tool versus other generation-related tools (e.g., generation_history or generation_submit). The description gives no context about typical use cases or conditions that would favor 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?

The description discloses that a visible output node is created before the provider request and that successful outputs remain reusable Assets, which adds useful behavioral context beyond the annotations. It does not cover failure modes, cancellation, or idempotency behavior, but the annotations already indicate idempotentHint=false and destructiveHint=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?

The description is concise at two sentences, places the primary action first, and adds relevant behavioral detail without 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?

Given the complex schema with nested references, parameters, and no output schema, the description provides insufficient context for correct usage. It mentions output node creation and reusable Assets but omits how parameters, references, or the revision field should be supplied or interpreted.

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

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

Schema description coverage is 0%, and the description does not explain any of the 10 parameters, including mode, modelId, references, idempotencyKey, or expectedRevision. The references nested object with roles and delivery URLs is entirely undocumented, leaving the agent without essential parameter guidance.

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 identifies the action as submitting a generation from a reviewed Canvas node and states that an output node is created, which distinguishes it from status, history, and model-list tools. However, 'submit from a reviewed Canvas generation node' is somewhat oblique and could be more explicit about initiating a generation.

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 siblings like generation_status, generation_history, or canvas_continue_from_tail. The phrase 'from a reviewed Canvas generation node' hints at a precondition, but no alternatives or exclusions are 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?

Annotations already declare idempotentHint=false and destructiveHint=false, and the description aligns with these by indicating a new project is created (non-idempotent) and that creation is not destructive. The description adds the qualifier 'local' but provides no further behavioral details such as naming conflicts, overwriting behavior, or side effects beyond creation.

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

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

The description is a single concise sentence with no redundant words. It states the essential action and resource clearly, 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 simple create operation with no output schema, the description conveys the core intent. However, it omits any mention of return value, success/error behavior, or potential confirmation steps, which could be relevant for an agent deciding how to handle the result. It is adequate but not fully complete for operational use.

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 fully defines the single parameter 'name' with type string and min/max lengths, so schema coverage is 100%. The description does not add any extra semantic detail about the name parameter (e.g., uniqueness, formatting, default values), but because the schema is complete, 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 verb 'Create' and the resource 'a new local BeatDesign project', distinguishing it from sibling tools like bdesign_project_list, bdesign_project_get, and bdesign_project_open. However, it does not explicitly differentiate itself from those siblings, relying on the phrase 'new local' to imply creation of a fresh project.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites, side effects, or typical use cases. An agent is left to infer that this is for creating projects, but there is no explicit statement about when to choose this over bdesign_project_open or bdesign_project_import.

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 readOnlyHint annotation is consistent with the description's 'Read' verb, so no contradiction. The description adds useful context about the return contents (Canvas and Editor documents) beyond the annotation, but does not disclose other behavioral aspects like error conditions or response structure. With annotation covering safety, the added value is moderate.

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 fluff, directly stating the core function. It is efficiently front-loaded 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?

Despite the simple tool, the complete absence of parameter documentation and any note about when to use this tool versus siblings leaves gaps. With no output schema and no parameter semantics, an agent may not know how to properly set includeAssets or whether projectId is required. This is incomplete for practical use.

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

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

Schema description coverage is 0%, meaning the description does not explain projectId or includeAssets at all. The schema defines them but the description provides no guidance on their meaning or usage. For a tool with two parameters, this is a significant gap that the description fails to compensate for.

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?

Description states a specific verb ('Read'), a specific resource ('one project'), and the included sub-documents ('Canvas and Editor documents'). This clearly distinguishes it from list, create, and other get tools like bdesign_canvas_get or bdesign_editor_get.

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 guidance on when to use this tool versus alternatives. It implies it fetches a project with its documents, but does not mention when one would prefer bdesign_canvas_get or bdesign_editor_get separately, nor any exclusions or prerequisites.

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

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

The readOnlyHint annotation already indicates this is a read-only operation, and the description ('List') is consistent. However, the description adds no additional behavioral context such as caching, authentication, or rate limits, so it meets the baseline for non-contradiction but does not enhance transparency.

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

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

The description is a single concise sentence with no redundant words. It directly conveys the action and object without any fluff or unnecessary detail.

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

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

Given the lack of an output schema and minimal description, the tool provides very little context. It does not clarify what a 'BeatDesign project' entails, what fields are returned, or how results are ordered. While a simple list may not require extensive detail, the description leaves significant ambiguity for an agent.

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 only parameter 'limit' is fully defined in the schema with type, default, and bounds, giving high schema coverage. The description does not explain the parameter's purpose, but 'limit' is self-explanatory in the context of listing. Thus it aligns with the baseline of 3 for well-schematized parameters.

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) and the resource (local BeatDesign projects). It is specific enough to distinguish from other listing tools like bdesign_asset_list, though it does not specify any filtering or sorting options.

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

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

No guidance is provided on when to use this tool versus alternatives such as bdesign_canvas_search or bdesign_asset_list. There is no mention of scenarios, prerequisites, or conditions for use.

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 idempotentHint=true, so the safety profile is covered. The description adds that the tool produces a browser handoff for live observation, which is useful behavioral context. It does not explain what a 'handoff' entails or whether it changes the current selection, but the annotations reduce the burden.

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

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

Two sentences with no filler. The core action is stated first, and the usage timing is front-loaded in the second sentence. 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 has four optional parameters and no output schema, yet the description leaves most parameter semantics unexplained. It also does not clarify how to identify the project or what a browser handoff returns. The read-only and idempotent annotations help, but the description alone is not enough for an agent to confidently call this tool with correct arguments.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only indirectly covers the view parameter by listing Canvas, Editor, Studio, and Assets. It does not explain projectId, time, or focusCardId, nor does it clarify that all parameters are optional or how the 'selected' project is determined.

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 tool returns a browser handoff for a BeatDesign project, which is a distinct action from project_get or canvas_view. It names the specific views (Canvas, Editor, Studio, Assets) that the handoff supports. It does not explicitly contrast itself with sibling tools, but the verb and resource are specific 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 description gives explicit timing guidance: 'Use it early so the user can watch Agent changes.' This tells the agent when in a workflow to invoke the tool. It does not mention alternatives or exclusions, but the early-use context is actionable and clear.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds context about the session-binding side effect and the return of a workspace handoff, which are not covered by annotations. No contradiction between the description and annotations; 'bind' is a client-side state change, not a server data 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?

The description is a single sentence that efficiently conveys the core purpose and return. It is front-loaded with the main action and avoids unnecessary detail, making it concise and well-structured.

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

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

With four parameters, zero schema descriptions, and no output schema, the description should explain parameter roles and the return format. It only covers the session-binding purpose and a vague 'workspace handoff'. It lacks details on time, view, focusCardId, and what exactly the handoff contains, leaving the agent under-informed.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions projectId implicitly through the binding purpose, but fails to describe time, view, or focusCardId at all. The phrase 'requested workspace handoff' hints at view but is not explicit. The description provides no semantic meaning for the majority of parameters.

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 tool's purpose: binding the MCP session to a BeatDesign project so later project-scoped tools can omit projectId. It also mentions returning a workspace handoff. This is a specific verb+resource and distinguishes it from siblings like project_open or project_get.

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: before other project-scoped tools that rely on the bound session. It explicitly mentions the benefit (later tools may omit projectId) and the return value. However, it doesn't state when not to use it or provide alternatives, but the usage context is fairly clear.

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