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

With no annotations, the description carries the full transparency burden. It discloses that probe:true makes real authenticated API calls but posts nothing, which is a key safety behavior. It does not explicitly state that the default (probe:false) is read-only, but 'Report' implies a non-mutating operation. Overall, the main behavioral risk (live calls) is well 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?

Two sentences, front-loaded with the primary action, followed by a directive and a conditional usage note. Every sentence earns its place; no filler or redundancy.

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

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

For a simple status tool with one optional parameter and no output schema, the description covers the what, when, and how (probe). It doesn't describe the return format, but given the tool's simplicity and lack of output schema, the description is sufficiently complete for an agent to invoke it correctly. A 5 would require explicit return value details.

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

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

Schema description coverage is 100% for the single 'probe' parameter, with the schema already explaining 'Live-verify social platform credentials (no posts are made)'. The description adds a slightly more explicit phrase about 'real authenticated API calls' but does not provide meaningful new meaning beyond the schema. Baseline 3 applies.

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

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

The description uses a specific verb ('Report') and enumerates exact resources (workspace location, ffmpeg availability, generation providers, social platform readiness). It clearly distinguishes itself from sibling tools like generate_image or publish_post by focusing on environment status rather than content operations.

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

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

The description explicitly says 'Call this first to see what is possible,' providing clear when-to-use guidance. It also explains when to use probe:true for credential verification. However, it does not explicitly name alternative tools or state when not to use it, though the role as a preliminary status check is strong.

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?

Since no annotations are provided, the description carries the full behavioral burden. It explicitly discloses that this tool does not publish, that drafts are files users can inspect, and that it validates against per-platform rules and reports violations. These are significant behavioral traits. However, it leaves the failure behavior ambiguous—whether a draft is created if validation fails—and does not mention return values or permissions. Thus it is transparent but has a minor gap.

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

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

The description is two sentences, front-loaded with the core purpose, and every sentence provides essential information. It is concise without any fluff or repetition, making it easy for an agent to quickly grasp the tool's function and constraints.

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 creation tool with no output schema and no annotations, the description covers the main purpose, validation, and non-publishing behavior, but it does not specify the return value format (e.g., draft ID, violations list) or the behavior when validation fails. The absence of an output schema means the description should provide more return-related details. It is adequate 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?

With only 33% schema description coverage, the description should compensate by explaining parameter meanings, but it primarily paraphrases the parameter names ('text + media + target platforms'). The mention of char limits and media counts/sizes gives some context about constraints, but it does not clarify details like acceptable text format or how platforms are specified (beyond the schema's enum). The description adds marginal value over 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 states the tool's purpose with a specific verb ('Create'), resource ('post draft'), and scope ('text + media + target platforms'). It distinguishes itself from sibling tools by explicitly noting that nothing is published and by referencing publish_post as the publishing alternative. This leaves no ambiguity about what the tool does.

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 a clear context for when to use the tool (creating a reviewable draft) and explicitly names an alternative ('use publish_post to send'). However, it does not explicitly mention exclusions such as 'use create_thread_draft for thread drafts', which would further strengthen the guidance. The context is still quite 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?

With no annotations provided, the description carries the full burden and does well: it discloses that posts chain as replies (Bluesky reply refs, X in_reply_to), that each post has text and up to 4 images, validation occurs per platform, and nothing publishes until explicit confirmation. It does not mention error scenarios or how drafts are saved, but for a draft-creation tool this is solid 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 three sentences: first states the action, second explains thread chaining and per-post content, third clarifies the publish flow. Every sentence earns its place with no filler, and key details are front-loaded.

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 2-parameter tool with no output schema and no annotations, the description provides a solid picture of thread structure, chaining, validation, and the publish gate. It lacks explicit mention of min/max posts (though 'multi-post' implies min 2) and doesn't detail platform-specific rules beyond validation, but overall it is sufficiently complete for typical 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%, so the description adds value by explaining that 'posts' items each have text and up to 4 images, which enriches the schema's generic 'media' array. However, the 'platforms' parameter is not explained beyond 'validated per platform,' leaving room for more clarity. Still, it meaningfully compensates for the schema gap.

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

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

The description begins with 'Create a multi-post thread draft,' a specific verb+resource statement that clearly distinguishes this tool from sibling create_post_draft. It elaborates on the thread chaining behavior (replies under first post) and mentions per-post text and images, making the purpose unmistakable.

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 multi-post threads and emphasizes that nothing is published until publish_post with confirm: true, providing clear context for the drafting vs publishing workflow. However, it does not explicitly name alternatives like create_post_draft for single posts or explicitly state when not to use this tool, leaving a slight gap in explicit exclusion guidance.

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

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

No annotations are provided, so the description must carry the transparency burden. It states the output (PNG frame) and the input (timestamp), which is core behavior, but it does not explicitly declare read-only status or any prerequisites/error behavior. For a simple extraction, this is moderately transparent.

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 is front-loaded with the main action and purpose. Every word contributes meaning, with no filler or redundancy.

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

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

The tool is simple, but the description is incomplete for an agent. It does not explain the 'asset' parameter, the units of atSec, or any constraints on the timestamp. With no output schema or annotations, these gaps matter for correct invocation.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only vaguely references 'timestamp' (which maps to the atSec parameter), but it does not clarify what 'asset' refers to or the units of the timestamp. This leaves the required parameter under-specified.

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

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

The description gives a specific verb ('Extract') and resource ('a single PNG frame from a video at a timestamp'), and even adds the use case 'visually QA a render'. This clearly distinguishes it from sibling tools like render_video or generate_video.

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 it to visually QA a render'. This tells the agent when to employ the tool, though it does not explicitly mention alternatives or when not to use it, which prevents a 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?

With no annotations, the description carries the burden of behavioral disclosure. It discloses external API key usage, fallback to a labelled mock, and that it returns workspace asset IDs. It does not mention failure modes, cost, or rate limits, but covers the most important behavioral traits.

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, front-loaded with the primary action, and every clause adds value: BYO-key, mock fallback, return type, and downstream uses. 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 5 parameters, no output schema, and no annotations, the description covers the core purpose and usage but misses parameter semantics and edge-case behavior. It is adequate for basic invocation but incomplete for complex scenarios like provider selection or error handling.

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 only 40% (label, provider), and the tool description adds no parameter-specific details. It does not explain prompt requirements, n limits, aspect options, or provider semantics, leaving the agent under-informed about how to set 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 it generates image(s) using the user's API keys, falls back to a mock, and returns workspace asset IDs. This distinguishes it from sibling tools like import_asset or generate_video by specifying exactly what resource it creates and how.

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 indicates when to use the tool by listing downstream consumers (render_video, render_carousel, post drafts). It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to infer appropriate usage.

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?

Discloses key behavioral traits: uses user's own API keys, switches between Gemini Veo and mock, and is expensive with real keys. This goes beyond the schema and annotations (none provided), adding operational context.

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

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

Two sentences, front-loaded with the core purpose and followed by a critical warning. No redundancy or vague 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?

Covers the most important behavioral context (provider, cost) but omits parameter details and return/output expectations. For a 4-param tool with no output schema, the description is too sparse to fully guide 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?

Schema description coverage is only 25% (provider), and the description does not explain prompt, aspect, or durationSec. The description mentions 'short video clip' but provides no param-specific meaning, leaving the agent to guess.

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 exactly what the tool does: 'Generate a short video clip'. The mention of 'Gemini Veo' and 'mock' differentiates it from siblings like render_video and generate_image, showing a specific AI-generated video use case.

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

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

Provides clear usage context: 'only call when the user’s workflow needs generated footage' and warns about cost with real keys. This gives an explicit condition for use and a caution, though it doesn't name alternative tools directly.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core action (copy, implying the original file remains) and the return value (an asset id). However, it does not mention potential errors, prerequisites like file existence/permissions, or the optional label behavior. It adds some value but lacks depth.

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 is front-loaded with the core action and resource, and every word earns its place. It includes the necessary file type constraint and the output (asset id) without any redundant or vague wording.

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 import tool with 2 parameters and no output schema, the description is fairly complete: it states what it does, what input is needed (local file with type constraints), and what is returned (asset id). It doesn't cover edge cases like duplicate names or label behavior, but for the tool's scope, the essential information 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 coverage is 50%; only 'path' has a description. The tool description adds meaning to 'path' by specifying it must be a local file of type image/video/audio, which goes beyond the schema's 'Absolute path.' However, 'label' is left completely undocumented in both the schema and the description, so the description does not fully compensate for the missing 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 states the action ('Copy'), the resource ('a local file'), the destination ('into the broll workspace'), and the outcome ('get an asset id for it'). It also specifies supported file types (image/video/audio), which distinguishes it from sibling tools like generate_image or generate_video that create assets rather than import them.

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

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

The description provides clear context: use this tool when you have a local file to bring into the workspace. It doesn't explicitly state when-not-to-use or mention alternatives, but the verb 'Copy' and the resource context make the usage scenario unambiguous.

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 states the scope (generated, imported, rendered) and optional filtering, but does not mention return format, pagination, or access considerations. 'List' implies read-only, though not explicitly stated.

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

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

A single, front-loaded sentence that states the core purpose and the optional parameter without any fluff. 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?

For a simple read-only listing tool with one optional parameter, the description is sufficient for an agent to select and invoke it correctly. It does not detail the response shape, but this is acceptable given the tool's simplicity.

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%, so the description compensates by explaining the 'kind' parameter as a filter. It adds meaning beyond the schema's enum values, though it could have named the possible values (image, video, audio, other).

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 'List workspace assets (generated, imported, and rendered)' uses a specific verb and resource, clarifies the asset types included, and clearly distinguishes from sibling tools like generate_image or import_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 purpose implies usage (when you need to enumerate workspace assets), but there is no explicit guidance on when to choose this tool over siblings (e.g., probe_asset for a single asset) or 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?

No annotations are present, so the description carries the full burden. It discloses the operation's read-only nature via the verb 'List' and specifies scope ('in the outbox') and returned data ('status and publish results'). However, it does not mention whether the operation requires special permissions, whether pagination exists, or how many drafts are returned, leaving some uncertainty.

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 action and resource, with no redundant words or filler. It is appropriately sized for the tool's simplicity.

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 no output schema, so the description must communicate return value expectations. It mentions 'status and publish results', which gives a general sense but lacks details on the full set of fields or any ordering/limitations. Given the tool's simplicity and sibling context (e.g., create_thread_draft), the description could clarify whether thread drafts are included, but it explicitly limits to post drafts.

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

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

The tool takes no parameters, and the input schema is empty with 100% description coverage. Per the rubric, a 0-parameter tool gets a baseline of 4. The description adds no parameter details because none are needed.

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

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

The description clearly states a specific action 'List' and a specific resource 'post drafts in the outbox', and further specifies the information returned ('status and publish results'). It distinguishes from siblings like create_post_draft and publish_post by being the listing counterpart, and there is no other listing sibling for drafts.

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

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

The description implies usage by indicating what it does, but does not explicitly state when to use it versus alternatives or mention exclusions. However, the context is clear: this is the tool to retrieve draft status and publish outcomes. No explicit when-not-to-use guidance is given, so it falls short of a 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?

With no annotations, the description carries the full burden. It does disclose the core behavior (inspection and return of specific metadata fields) and input handling, but it does not explicitly state read-only status, side effects, or error conditions. The term 'Inspect' implies non-mutation, but the lack of an explicit safety guarantee keeps it from a higher score.

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

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

Two short sentences, front-loaded with the primary action and return values. Every word earns its place: no fluff, no repetition. The structure is ideal for quick parsing.

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 simplicity (one required parameter, no output schema), the description adequately covers the purpose, input format, and expected output. It does not mention error handling or supported file types, but these are not critical for a basic inspection tool and would be better suited for a more complex tool.

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

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

The schema provides only a bare string parameter with no description (0% coverage). The description compensates well by explaining that the parameter accepts an asset id or an absolute path, giving the agent the necessary format context. It could further elaborate on constraints (e.g., file type), but for a single parameter this is solid.

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 'Inspect' and names the resource (media file), then enumerates the exact return fields (duration, dimensions, codecs, streams). This clearly distinguishes it from sibling tools like generate_video or import_asset, which create or import rather than inspect.

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

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

The description gives clear context: it is for inspecting an existing media file and supports two input forms (asset id or absolute path). It does not explicitly mention alternatives or exclusions, but the verb 'Inspect' and the focus on metadata make the use case unambiguous.

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 the confirm requirement, independent platform failure with setup instructions, and the special behavior of 'export' always succeeding. This goes beyond a simple 'publish' statement, though it omits side effects or success return details.

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 three sentences, with the purpose front-loaded, followed by the critical safety condition, then platform behavior. Every sentence adds value; 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 tool with no output schema, the description covers the essential operational aspects: confirmation, per-platform failure modes, and the export special case. It does not describe return values or async behavior, but the critical user-approval and partial-failure semantics are well covered.

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 67% (confirm and platforms have descriptions, draftId does not). The description adds depth for confirm (explicit user approval) and clarifies platform failure behavior, but it does not explain draftId or the subset-filtering aspect of platforms beyond what the schema already states.

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

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

The description starts with 'Publish a draft to its target platforms,' which clearly states the action (publish), the resource (draft), and the destination (platforms). This distinguishes it from sibling draft-creation tools like create_post_draft and create_thread_draft.

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 explicitly states the key usage condition: 'Requires confirm: true — never call this without the user’s explicit go-ahead in the conversation.' This provides clear when-to-use guidance. It does not mention alternatives, but the context of publishing vs. creating drafts is evident from the 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?

With no annotations, the description carries the full burden. It discloses deterministic rendering (layout, fonts, accent bar, page numbers, watermark) and explains that backgrounds can be plain color or an image asset, plus returns one asset per slide. This adds meaningful behavioral context beyond the schema.

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 compact two-sentence structure that front-loads the core purpose, then adds key behavioral details. Every clause contributes meaning, and there is no redundant or filler 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?

Despite a complex nested schema and no annotations or output schema, the description does not sufficiently contextualize how to invoke the tool. It omits the structure of the 'spec' object, available sizes/formats, limits, or any guidance on constructing slides, making it incomplete for reliable agent 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 top-level 'spec' parameter has no schema description, and the tool description does not explain its structure. While the description mentions watermark and background capabilities, it fails to cover other fields like size, format, pages, or slide content, leaving the agent without sufficient understanding of how to construct valid input.

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 function: 'Render branded carousel slides' with a specific format (Instagram/LinkedIn). This distinguishes it from sibling tools like render_video and generate_image, making its purpose immediately 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?

The description implies usage for social media carousels by naming the Instagram/LinkedIn format, and mentions the output style. However, it does not explicitly state when to use this tool over alternatives, nor does it provide exclusions or preconditions.

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

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

With no annotations, the description carries the disclosure burden and does well by explaining determinism, the absence of generation keys, the processing order of clips, burning in overlays/captions, music mixing, and the output asset id. It lacks explicit side-effect or failure-mode details, but these are secondary for a create-and-return 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 two concise, information-dense sentences. It front-loads the primary action and output, then expands with the key processing steps without any filler or redundant 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?

Given the complex nested schema and no output schema, the description covers the essential behavior (purpose, process, return value). It does not mention progress checks or failure handling, but the description is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to the sole `plan` parameter by defining it as a 'declarative RenderPlan' and explaining how its components (clips, overlays, captions, music) are processed. It does not enumerate all nested properties like fps, aspect, or quality, but those are present 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 clearly states what the tool does: 'Compile a declarative RenderPlan into an mp4 via ffmpeg'. It details the scope with specific processing steps (concatenation, overlays, captions, music) and return value, distinguishing it from siblings like render_carousel.

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 clear context for when to use it ('deterministic, brand-aware, no generation keys needed') and describes the input ('declarative RenderPlan'). However, it does not explicitly mention alternatives or when not to use this tool (e.g., render_carousel for carousels, generate_video for generative content).

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 transparency burden and does well by disclosing the merge behavior, the non-destructive 'never clobbers' property, and the explicit confirm requirement with rationale. It does not detail return values or error handling, but these are less critical 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 two sentences with no filler. It front-loads the action and purpose, then adds a critical safety note. Every clause adds value, making it appropriately 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?

Given the tool's moderate complexity and lack of annotations or output schema, the description covers purpose, behavior, and safety confirmation. It omits details like maximum lengths (already in schema) and return values (not needed without output schema), but overall it is sufficiently complete for an agent to understand and invoke the tool.

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

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

The schema covers only 50% of parameters (confirm and avatarAsset have descriptions). The description compensates by explicitly naming displayName, bio, and avatarAsset in human terms and explains the confirm parameter's purpose. It adds semantic meaning beyond the schema's terse field names.

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

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

The description uses a specific verb ('Update') and resource ('Bluesky profile'), listing the exact fields (display name, bio, avatar image). It clearly distinguishes itself from sibling tools, which focus on content creation or asset management, not profile settings.

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 the tool: it merges with the existing profile, avoids clobbering, and requires confirm because it changes public account data. It does not explicitly name alternatives, but sibling tools are unrelated, making this the obvious choice for profile updates.

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