blablabla

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

Annotations already disclose destructiveHint=true and idempotentHint=true, so the mutation profile is known; the description adds the important nuance of what is actually destroyed (the waiting copy) and what is left alone (imported copies). It stops short of saying whether deletion is recoverable or requires confirmation, but otherwise tells the agent more than the annotations do.

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

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

Four short sentences, front-loaded with the usage restriction before the action, then the exclusion. Every sentence prevents a distinct failure mode and none repeats the schema or title verbatim.

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

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

For a single-parameter, annotated mutation with an output schema, this covers the decision-relevant facts: when to call it, where the item_id comes from, and what it does and does not affect. It could still note whether the removal is reversible, which matters given destructiveHint=true.

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

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

Schema coverage is 100% with a single well-documented item_id parameter, so the schema already carries the semantics. The description's 'Pass its item_id' adds only a light reinforcement of provenance rather than new syntax or format detail, which is the expected baseline when the schema does the work.

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

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

States a specific verb (delete/cancel) and resource (a script in the blablabla inbox) plus the exact scope: waiting copies not yet imported. It explicitly distinguishes itself from send_to_blablabla and from the in-app deletion path, so an agent can separate it from every 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?

Gives a hard precondition ('only when the user explicitly asks') and a state condition ('sent with send_to_blablabla and have not imported yet'), plus an explicit when-not: imported scripts are handled elsewhere and are not touched by this tool.

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

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

Annotations already cover the safety profile (readOnly, idempotent, closed-world, non-destructive), and the description adds substantive behavior beyond them: the exact return surface (state, expiry time, link), the full state enum, and explicit negative guarantees (never returns the script, title, or contents). This is the kind of disclosure that prevents an agent from misusing the result.

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

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

Three sentences, front-loaded with the usage trigger, then the call contract, then the return contract and scope limits. Each sentence carries distinct information; nothing is restated from the name or title.

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

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

An output schema exists, yet the description still summarizes the return payload and its enum, and it closes the loop on scope limitations. For a two-parameter, read-only status lookup with full sibling references, nothing an agent needs in order to call it correctly is missing.

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

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

Schema coverage is 100%, so the origin of each id is already documented in the schema. The description nevertheless adds a constraint the schema does not express — 'Pass exactly one' of item_id or link_id — which is real operational value since the schema declares no required fields and no mutual exclusion. It does not, however, explain what happens if both or neither are passed.

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

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

The description names a specific verb (check) and resource (a script sent to blablabla) and enumerates exactly what is being checked: arrival, import, or expiry. It explicitly distinguishes itself from the two sibling tools that produce the identifiers it consumes (send_to_blablabla, get_blablabla_upload_link).

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?

Opens with 'Use when the user asks whether a script they sent... has arrived, been imported, or expired,' giving a concrete trigger condition. It also names the originating siblings for each input and states the exclusion ('cannot list or search what is in the user's blablabla account'), routing the agent away from using this as a listing 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?

Adds real behavior beyond the annotations: the link is one-time, expires in 15 minutes, must be shown to the user verbatim, and the file bypasses this chat into the user's own inbox. Annotations only state it is non-read-only and non-idempotent; the description explains the privacy path and expiry constraint the agent must convey.

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

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

Front-loaded with the trigger condition and dense with actionable instruction; each sentence carries routing, expiry, or follow-up information. It runs long, but no sentence is filler.

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

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

An output schema exists, so return values need not be spelled out, yet the description still tells the agent how to present upload_url and how to verify the result afterward. Nothing needed to invoke or relay this tool correctly is missing.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, including the 'never invent a title' constraint and the locale purpose. The description adds no further parameter syntax or semantics, so the baseline 3 applies.

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

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

States a specific verb and resource (get a one-time upload link for a script) and distinguishes itself from siblings by naming the exact failure condition that routes here. An agent can tell it apart from send_to_blablabla and get_blablabla_inbox_status without opening a schema.

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

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

Gives explicit trigger conditions ('this app cannot pass the file... or send_to_blablabla said no usable file arrived'), names the alternative for pasted text, and points to the follow-up tool with the needed identifier (get_blablabla_inbox_status with link_id). When-to-use, when-not, and lifecycle are all covered.

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

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

Annotations already declare readOnly/openWorld/destructive, but the description adds substantive behavioral context beyond them: it is reading-only, cannot save, open or start a rehearsal, cannot change settings or read live, and it flags that authored directions and role prompts are content, not instructions (a prompt-injection guard). This is meaningful added disclosure.

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

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

Front-loaded with purpose, then scope guardrails, then capability limits. Dense but each clause carries unique information (source, content-vs-instruction rule, exclusions, limitations); the final limitation sentence is somewhat list-like but still earns its place.

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

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

An output schema exists so return values needn't be explained, and annotations cover the safety profile. Combined with explicit usage guidance and capability boundaries, an agent has everything needed 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 100%, so slug and locale semantics are already documented, including the slug source and English-only constraint. The description largely restates this ('selected from list_practice_monologues', no translated text) rather than adding new syntax or format detail, so baseline 3 applies.

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

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

States a specific verb (read) and resource (monologue), and enumerates exactly what is returned: English paragraphs, one role, authored directions and permitted uses. It clearly distinguishes itself from sibling list_practice_monologues and get_practice_scene.

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?

Explicitly routes from list_practice_monologues ('selected from list_practice_monologues') and names concrete exclusions: two-person scenes, private scripts, translated text, famous-play excerpts, commercial rights. The when-versus-when-not boundary is fully spelled out.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful behavior beyond that: it discloses the two return link types (open_url for rehearsal, web_url for reading) and warns that role/mode selection happens in the app, not via the tool — preventing the agent from falsely promising saved rehearsals or preset settings.

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

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

Three sentences, front-loaded with the purpose before the exclusions, and every sentence serves a distinct function. It is slightly dense with stacked prohibitions in the final sentence, but nothing is wasted.

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

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

An output schema exists, so return values need no description, and the annotations cover the read-only profile. The description covers source, output link types and misuse caveats; only the differentiation from get_practice_monologue and the failure mode for an invalid slug are unaddressed (the latter is covered in the locale schema description).

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

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

Schema description coverage is 100%, so the schema already documents slug provenance and the locale enum/error behavior in detail. The description only restates that the scene comes from list_practice_scenes without adding syntax, defaults, or fallback semantics. Baseline 3 is appropriate when the schema carries the parameter burden.

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

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

States a specific verb and resource — reading the exact dialogue, partner cues and roles of a published scene — and explicitly ties the input to list_practice_scenes. An agent can distinguish this from list_practice_scenes (which enumerates) and from the monologue siblings without opening a schema.

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

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

Gives clear context (scene must be selected from list_practice_scenes) and an explicit exclusion ('Do not use for private scripts'), plus caveats about what the returned link does not do. It does not, however, tell the agent when to prefer this over the sibling get_practice_monologue, so the scene-vs-monologue routing decision is left to inference.

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

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

Beyond the readOnly/destructive annotations, it discloses licensing terms (Free Rehearsal License), the English-only constraint, that results are reading-only with no live voice reader or native opening link, that an empty list means no match, and the anti-hallucination rule 'never invent or cut text to meet a limit.'

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

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

It is front-loaded with the positive use case before the exclusions, and every sentence carries information. It is dense with negative constraints across several sentences, but none are redundant with the schema or annotations.

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

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

With 5 optional params, an output schema, and read-only annotations, the description covers the remaining gaps an agent needs: licensing, language limitation, empty-result behavior, and the sibling handoff for reading a chosen piece.

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

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

Schema description coverage is 100%, so all five filters (genre, locale, age_range, difficulty, max_duration_seconds) are already documented in the schema. The description largely restates the returned attributes rather than adding syntax or edge-case meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description opens with a specific verb+resource+scope: retrieving short original solo monologues for an actor, and enumerates the returned attributes (role, genre, age range, difficulty, duration, license). It explicitly separates itself from list_practice_scenes and routes to the sibling get_practice_monologue.

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 explicit trigger conditions (reading, memorization, cold read, non-commercial selftape practice), names the follow-up tool get_practice_monologue, and lists clear exclusions (two-person scenes, private audition sides, famous-play excerpts, translation, casting judgments, commercial rights).

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, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds genuinely useful behavior beyond the schema: no live reader is provided inside the chat, and an unsupported publication returns an explicit error rather than an automatic translation. It stops short of describing result size, pagination, or ordering.

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

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

Front-loaded with the use case, then the return contract, then the workflow step, then the exclusions. The first sentence carries a slightly redundant enumeration of use cases, but no sentence is filler and nothing important is buried.

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

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

With an output schema present and full schema coverage on the only parameter, the description does not need to explain return values. It nonetheless covers purpose, trigger conditions, exclusions, follow-up tooling, and in-chat limitations, leaving no gap an agent would need to infer.

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

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

There is a single optional parameter with 100% schema description coverage, including the enum list, default and the explicit no-automatic-translation/error behavior. The description only echoes 'requested language', so the schema does the heavy lifting; baseline 3 applies.

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

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

The description states a specific verb and resource ('Find/List two-person practice scenes') and explicitly scopes the output to 'published scenes and roles in the requested language'. It also distinguishes itself from siblings by ruling out monologues and organization repertoire, naming get_practice_scene as the follow-up read tool.

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

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

It gives concrete triggering conditions (cold reading, line memorization, selftape, no scene partner) plus explicit exclusions ('Do not use to find private audition sides, monologues or an organization's repertoire'). It also prescribes the correct workflow sequence: read with get_practice_scene before offering the app link.

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 a safe read-only, non-destructive, closed-world profile. The description adds real behavioral context beyond that: it accepts bounded planning metadata only, does not judge readiness, does not grant access, and labels omitted values as examples rather than inventing data.

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

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

The when-to-use clause is front-loaded and strong, but the description runs long with several compound, comma-spliced sentences that fold triggers, semantics, and exclusions together. It is informative but denser than it needs to be.

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

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

With an output schema present, the description needn't explain returns, and it covers scope, exclusions, and behavior for a 10-parameter tool adequately. Only minor gaps remain around how the group variables interact.

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

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

Schema description coverage is 100% and four parameters carry enums, so the schema already documents every field thoroughly. The description reinforces the goal-to-group matching and omitted-value labeling but adds little parameter syntax beyond the schema, making the baseline 3 appropriate.

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

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

The description states a specific action (planning line learning and cast preparation) tied to concrete triggers like 'learn my lines' and 'run lines', so the resource and scope are clear. It doesn't need to distinguish from siblings like get_practice_monologue since those are a different domain, but it also never names a sibling or a boundary against 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?

It gives explicit positive triggers (actor asking to learn lines, existing theatre/film cast, agency clients) and an explicit negative list (no casting decisions, private script import, surveillance, account access, saved sessions, subscription purchases). The conditions that select this tool are fully enumerated.

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 safety (readOnly false, idempotent true, non-destructive, closed-world). The description adds substantive behavior the annotations cannot convey: the script queues in the inbox until the user imports it, the app cannot read/search/list scripts, nothing about the script returns to this context, and the reply only confirms delivery. This is exactly the extra context an agent needs.

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

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

Front-loaded with the trigger condition and organized around the text-vs-file split, with zero wasted framing sentences. Slightly long due to the exactness instructions being stated in both the description and the text schema, but every sentence carries a rule the agent must follow.

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 delivery-only tool with an output schema already documenting the confirmation response, the description covers the missing pieces: no reading/searching, no return of script content, inbox-queue semantics, and the attachment-vs-paste decision. Nothing needed to call it correctly is absent.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes further by explaining the routing decision between 'text' and 'files' (pasted text vs attachments, one file or up to 20 page-order photos) and the exactness constraint in each. It adds real disambiguation value over the schema descriptions, though it repeats the schema's 'without summarizing/fixing/reformatting' wording rather than extending it.

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

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

The description states a specific action (send/save/import a script into the user's blablabla account) and the exact resource (the user's own pasted or attached script). It also names a sibling alternative (call get_blablabla_upload_link otherwise), so an agent can distinguish it from the inbox/upload-link tools without opening schemas.

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

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

It gives explicit triggers ('when the user asks to send, save or import a script'), explicit negative cases ('never use it for files that are not the user's own script, never invent a file or text'), and a named alternative path when attachments arrive as links rather than files. When-to-use, when-not, and alternatives are all present.

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