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

With no annotations, the description fully discloses behavioral traits: it lists actions like delete as irreversible and requiring confirm=True. It also describes each action's purpose. The existence of an output schema covers return values, so no further elaboration needed.

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 well-structured: a concise opening summary, then a bulleted list of actions, then parameter explanations. It is slightly lengthy but efficiently organized, front-loading the 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?

Given the tool's complexity (9 parameters, multiple actions), the description covers actions, parameter usage, and notable constraints (e.g., confirm for delete). The presence of an output schema fills in return structure, making it complete for agent 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%, but the description provides meaningful explanations for each parameter (e.g., query for action=query, source_url for add_source, notebook_names as comma-separated strings). This adds value beyond the raw 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 it performs batch operations across multiple notebooks, listing specific actions. It distinguishes itself from sibling tools like notebook_create, notebook_delete, and source_add by being a batch operation 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?

The description provides clear usage context within the tool (e.g., actions and their parameters). However, it does not explicitly state when to use this tool versus alternative individual tools (e.g., notebook_create for single notebook creation), which would help an agent decide between siblings.

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

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

With no annotations, description carries full burden. It does not disclose whether the tool is destructive/reversible, what it does to existing settings, or any authentication requirements. Only parameter constraints are mentioned.

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?

Extremely concise: purpose stated first, then parameter list in clean format. No superfluous text. Every sentence is informative.

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 parameters are described, the overall effect of configuration (e.g., what goal or response_length actually do) is missing. Return value or success indication not mentioned. Annotations are absent. An output schema exists but description does not reference 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?

Adds valuable meaning beyond schema: explains custom_prompt is required when goal=custom with a max length constraint. This conditional logic is not in the schema. However, 0% schema coverage means more explanation would be beneficial.

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 clearly states 'Configure notebook chat settings' with a specific verb and resource. It distinguishes from sibling tools like chat_list and chat_get, which list/get chats, by indicating configuration. However, it could be more explicit about modifying existing 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?

No guidance on when to use chat_configure vs alternative tools. It does not specify prerequisites or conditions (e.g., notebook existence, permissions) or exclude 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?

No annotations are provided, so the description carries the burden. It mentions rate limits for all=True and describes the output format. However, it does not explicitly state that the tool is read-only or disclose other behavioral traits like error handling or synchronization.

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: a brief summary followed by an Args list. Every sentence adds value, with no fluff. It is well-structured and front-loaded with 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?

Given there is an output schema (unseen), the description covers the main aspects: query purpose, parameter options, and output format. It lacks details on error handling, authentication, or concurrency, but is sufficient for basic 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 must fully document parameters. It describes all four parameters with examples (e.g., 'AI Research, Dev Tools') and their roles. It adds meaning beyond the schema types, though it omits explicit mention of defaults for notebook_names and tags.

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 'query', resource 'multiple notebooks', and output 'aggregated answers with per-notebook citations'. This distinguishes it from sibling 'notebook_query' which likely queries a single notebook.

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 explains how to specify notebooks (by name, tags, or all=True) and includes a caution for all=True about rate limits. However, it does not explicitly state when to use this tool versus alternatives like notebook_query, though it is implied.

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

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

No annotations are provided, so the description carries full burden. It describes the tool as downloading artifacts to a file, lists parameters, and shows return type. It does not disclose overwrite behavior or auth requirements, but for a download tool this is acceptable.

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 well-structured with Args, Returns, and Examples sections. It is a bit lengthy but every sentence adds value. Could be slightly more concise, but overall 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?

Given the tool has an output schema (context confirms), the description adequately explains return values. It covers all aspects: what it does, parameters, examples, and supported formats. No gaps remain.

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 0% description coverage, so the description must compensate. It fully explains each parameter, including artifact_type values, optional artifact_id, output_format for quiz/flashcards, and slide_deck_format. Examples clarify usage.

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 is a unified download tool for NotebookLM artifacts, listing all supported types and replacing 9 separate tools. It distinguishes itself from siblings by covering multiple artifact types in one 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?

The description explicitly states when to use the tool (to download any artifact) and provides examples. It does not explicitly mention when not to use or name alternatives, but the unified nature makes guidance 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?

No annotations provided. Description states it exports and returns a URL, but does not disclose permissions, side effects (e.g., whether it creates a new document in user's drive), or any destructive behavior. It is a read-like operation but not explicit.

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?

Description is concise, uses bullet points for supported conversions, and front-loads the core action. Every sentence adds value; no unnecessary 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?

Given an output schema exists (so return value is covered), the description covers all parameters, supported conversions, and the return URL. It could mention error conditions or prerequisites, but overall complete for 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 description must compensate. It lists three required parameters and one optional, and explains the mapping of export_type to target format. However, it does not specify valid values for export_type as an enum or describe format constraints for IDs.

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 exports an artifact to Google Docs or Sheets, with specific mappings (Data Tables → Sheets, Reports → Docs). It uses a specific verb+resource and distinguishes from sibling tools like download_artifact.

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 (export to Google Docs/Sheets) but does not explicitly tell when not to use or compare to alternatives like download_artifact. No exclusion criteria or context-driven 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?

With no annotations, the description carries the full burden, detailing behaviors like destructive actions ('delete permanently'), required confirmations, and preconditions (5+ sources). However, it omits some aspects like error behavior or rate limits.

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

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

The description is well-structured with a summary, enumerated actions, parameter details, and multiple examples. Every sentence adds value, and the most critical information is 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?

Given 9 parameters, no annotations, and an output schema, the description covers all actions, parameter requirements, preconditions, and examples, making it complete 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 coverage is 0%, but the description adds rich meaning for all parameters, listing valid actions, required fields per action, and examples, fully compensating for the lack of schema descriptions.

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 as 'Manage source labels in a notebook' and emphasizes it's a 'Unified tool for all label operations,' distinguishing it from siblings like 'tag' by covering all label-related actions.

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 detailed usage for each action (e.g., 'requires 5+ sources for auto-labeling', 'confirm=True needed for delete'), but does not explicitly mention when to use alternative sibling tools or exclude them.

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

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

No annotations are provided, so the description carries full burden. It discloses that delete is permanent and requires confirm=True, and describes parameter dependencies per action. It does not cover rate limits or auth, but is otherwise 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 concise, well-structured with bullet points, and includes four clear examples. Every sentence adds value without 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?

Given the tool's complexity (6 parameters, 4 actions) and the presence of an output schema, the description provides all necessary context: parameter details, action-specific requirements, and concrete examples. No gaps remain.

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%, but the description thoroughly explains each parameter, including required conditions, defaults, and valid actions. This fully compensates for the lack of schema descriptions.

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 is a unified tool for all note operations, listing create, list, update, delete. It distinguishes from sibling tools by focusing specifically on notes within a notebook.

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 covers all note operations and provides examples, but does not explicitly state when not to use it or mention sibling tools for comparison. However, it is clear enough for an agent to understand its scope.

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 only states the creation action without disclosing side effects, auth requirements, or constraints such as duplicate title handling. Since no annotations are provided, the description carries full burden but adds minimal behavioral 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?

The description is very concise with no wasted words, front-loading the action effectively. It includes an args section in a clear format, though it could be slightly more informative without harming conciseness.

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 creation tool with one optional parameter and an output schema, the description is minimally adequate. However, it omits details about what constitutes a notebook (e.g., structure) and any prerequisites, leaving some gaps 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 input schema has 0% description coverage, but the description adds 'Optional title for the notebook,' which clarifies the parameter's optionality and role. This provides some added meaning beyond the schema's default value, though it lacks details like length limits.

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 'Create a new notebook.' clearly states the action (create) and the resource (notebook). It distinguishes the tool from siblings like notebook_list, notebook_get, and notebook_delete, which have different purposes.

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 notebook_import or notebook_clone. There are no when-to-use or when-not-to-use indicators, leaving the agent to infer usage without 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?

No annotations are provided, but the description explicitly declares 'IRREVERSIBLE' and notes the confirm parameter requirement, fully disclosing the destructive nature.

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 short and efficient, but could be slightly more structured (e.g., separate sections). However, it is clear and to the point.

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 delete tool, the description covers all essential aspects: action, irreversibility, required parameter confirmation. Output schema exists, so return value explanation is not needed.

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%, yet the description adds crucial meaning: notebook_id is a UUID, confirm must be True after user approval. This compensates for the schema's lack of descriptions.

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 ('Delete') and resource ('notebook'), clearly indicating permanent deletion. It distinguishes from sibling tools like notebook_rename and notebook_query.

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

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

The description states the requirement for confirm=True and user approval. While it does not explicitly compare to alternatives, the action is unambiguous and guidelines are implied.

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

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

With no annotations, the description carries full burden. It discloses the return format (summary in markdown, suggested topics list), but does not mention that the summary is AI-generated (which may imply latency, cost, or content considerations). No side effects or restrictions are noted, leaving behavioral traits partially unspecified.

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 short and front-loaded, with the purpose in the first sentence. The inclusion of an args block is slightly redundant but acceptable. Every sentence contributes value.

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 presence of an output schema (not shown), the description could omit return details but chooses to include them, which is helpful. However, it does not explain what 'suggested topics' means or any prerequisites for the notebook (e.g., must have content). The completeness is adequate for a simple summary tool but could be richer.

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, but the description adds 'Notebook UUID' to the notebook_id parameter, clarifying its expected format beyond the schema's type string. This adds meaningful semantics for a single required 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 clearly states the tool returns an AI-generated notebook summary with suggested topics. This distinguishes it from siblings like notebook_get (which likely returns raw metadata) and notebook_query (which runs queries). The verb-resource combination is specific and unambiguous.

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

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

The description implies the tool is for obtaining a summary, but it does not explicitly state when to use this instead of other notebook tools (e.g., notebook_get for raw data, notebook_query for specific queries). No exclusions or alternatives are mentioned, leaving the agent to infer 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?

With no annotations, the description solely communicates a read operation ('get'). It does not disclose any behavioral traits such as data scope, permission requirements, or side effects. The term 'sources' is vague and not explained.

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 very concise with two sentences covering the action and single parameter. No unnecessary words. However, it could be expanded slightly for clarity without violating conciseness.

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 existence of an output schema, the description doesn't need return value details, but it fails to explain what 'details' and 'sources' mean. The tool has many siblings (e.g., notebook_describe, notebook_list), and the description provides no context for selection, making it incomplete 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 description only repeats the parameter name and type ('Notebook UUID'), adding minimal semantic value beyond the schema. At 0% schema description coverage, the description should elaborate on the parameter's purpose or format, but it does not.

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 'Get notebook details with sources', specifying the verb and resource. However, it does not explicitly distinguish from sibling tools like notebook_describe or notebook_list, so there is room for improvement.

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 (e.g., notebook_list for summaries, notebook_describe for different details). The description lacks any usage context 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?

No annotations provided. The description lacks details on pagination, ordering, or filtering behavior beyond max_results. It does not disclose whether the list is complete or limited.

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 short and to the point, with two sentences. But the parameter description could be integrated more naturally. No wasted words.

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

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

Given the tool's simplicity and presence of output schema, the description is adequate but lacks details on return format or pagination behavior. It could mention that notebooks are returned as a list.

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 description must compensate. It explains max_results parameter with default value, adding meaning beyond schema. However, it could specify whether results are sorted or if there is a maximum limit.

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 'List all notebooks,' which is a specific verb+resource. It distinguishes from sibling tools like notebook_get, notebook_create, and notebook_delete.

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

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

No guidance on when to use this tool vs alternatives like search or filter tools. The description does not mention excluded scenarios 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool queries existing sources (non-destructive), defaults source_ids to all, and timeout to environment variable or 120.0 seconds. It does not mention any side effects or constraints, but as a query tool it is expected to be read-only.

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: a single-line purpose statement, a comparison line, then a structured parameter list. Every sentence adds value, with no repetition 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?

Given the tool's complexity (5 parameters, 2 required, output schema present), the description covers all parameter semantics, usage context, and defaults. The output schema handles return values, so no additional return description is needed.

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 0% description coverage, so the description compensates fully by explaining each parameter in the Args section, including defaults and optionality. The description adds meaning beyond the schema's type definitions.

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 asks AI about existing sources in the notebook, and explicitly contrasts with research_start for finding new sources. The verb 'ask' and resource 'existing sources' are specific and 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 explicit when-to-use and when-not-to-use guidance, naming the alternative tool (research_start) and listing its use cases. It also explains each parameter's purpose, including defaults and environment variable fallback.

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?

Describes asynchronous behavior (returns immediately with query_id), timeout handling, and the polling workflow. No annotations provided, so description carries full burden. Does not mention auth or side effects, but it's a query initiation 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?

Concise, well-organized: intro sentence, when-to-use, workflow, then parameter list. Every sentence adds value with no redundancy.

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

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

Covers purpose, usage, workflow, and parameters. Output schema exists so return values are not required. Complete for an async query start tool.

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

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

Schema description coverage is 0%, so description adds meaning for all 5 parameters: notebook_id, query, source_ids (default all), conversation_id (for follow-ups), timeout (default from env or 120s). Provides context beyond the bare 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?

Clearly states the tool starts an asynchronous notebook query for large notebooks that may timeout. Uses specific verbs ('Start', 'poll') and distinguishes from sibling tool notebook_query by specifying alternative 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?

Explicitly advises when to use this tool instead of notebook_query: when querying notebooks with many sources (50+) or timeouts over 60 seconds. Provides a clear workflow: start then poll notebook_query_status.

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 provided, so description carries full burden. It discloses that the tool returns query result or current status, and mentions polling behavior. However, it lacks details on error handling, side effects, or rate limits. Adequate but not comprehensive.

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 and well-structured: a clear purpose statement, behavioral note, polling instruction, and args section. Every sentence adds value, no 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?

Given the presence of an output schema (not shown but indicated), the description adequately covers the tool's behavior. It explains return values (result or status) and polling usage. No gaps for a simple polling 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?

Only one parameter (query_id) with 0% schema description coverage. The description adds meaning by stating 'The query ID returned by notebook_query_start', linking it to the start tool. This compensates for the schema's lack of description.

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 'Check the status of an async notebook query started with notebook_query_start', specifying the resource (async notebook query) and action (check status). It distinguishes from sibling tools like notebook_query_start which initiates the query.

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

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

Provides explicit polling guidance: 'Poll this tool every few seconds until status is 'completed' or 'error'.' This indicates when and how to use it after starting a query. No explicit alternatives or when-not, but the advice is 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?

No annotations provided, and the description lacks behavioral details such as side effects, permissions needed, or error conditions. For a mutation tool, more transparency is expected.

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?

Very concise with a clear one-sentence purpose and a list of parameters. Could be slightly more structured but 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?

Despite having an output schema (not shown), the description does not explain return values. Lacks behavioral context and usage guidelines, making it incomplete 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?

Schema description coverage is 0%, but the description lists parameter names and types in Args, adding minimal value beyond the schema itself. No further semantic detail about constraints or formats.

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 explicitly states 'Rename a notebook,' using a specific verb and resource. It distinguishes from sibling tools like notebook_delete and notebook_query.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention prerequisites, exclusions, or context for 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?

With no annotations, the description carries full burden. It discloses the mandatory 'confirm' parameter after user approval and explains the return structure. However, it could add details on error handling or partial failures.

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 and well-structured with clear sections. It could be slightly more scannable, but it appropriately front-loads the 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?

Given the presence of an output schema, the description covers purpose, parameters, and return format. It could mention edge cases or idempotency, but is sufficient 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 coverage is 0%, so the description must compensate—and does so fully. It explains each parameter: notebook_id as UUID, recipients as list of dicts with default role, and confirm as boolean requiring True. An example is provided.

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 'Invite multiple collaborators in a single request,' specifying the verb (invite), resource (collaborators), and scope (batch). This distinguishes it from sibling tools like notebook_share_invite (single invite) and notebook_share_public.

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 batch invitation but does not explicitly contrast with alternatives or provide when-to-use guidance. It lacks exclusion criteria or mention of prerequisites.

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

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

With no annotations, the description bears full burden. It only states 'Returns: success status', lacking details on error handling (e.g., invalid email, duplicate invite), side effects, or required permissions. Behavioral traits are minimally 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 concise with no extraneous words. It lists parameters clearly but could benefit from a more structured format (e.g., bullet points) for readability.

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

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

Given the presence of an output schema (not shown), return details may be there, but the description only says 'success status'. Lacks context on error conditions, idempotency, and whether the operation is reversible. Moderate completeness.

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 description adds meaning: notebook_id is 'Notebook UUID', email is 'Email address to invite', role has explicit enum values ('viewer' or 'editor') with default. This compensates for missing schema descriptions.

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 'Invite a collaborator by email', specifying the verb 'invite' and the resource 'collaborator'. It distinguishes from sibling tools like notebook_share_status (status check) and notebook_share_public (public sharing) by focusing on email invite.

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 inviting a specific user via email but does not provide explicit guidance on when to use this tool versus alternatives (e.g., batch share). No 'when not to use' or context about prerequisites.

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

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

No annotations provided, so description carries full burden. It discloses the toggle behavior and return values (public_link if enabled, None if disabled). It could mention that enabling makes the notebook publicly accessible, but the intent is clear.

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

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

The description is concise, using a docstring-style format with Args and Returns sections. It is front-loaded and each sentence provides necessary information without 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?

Tool has output schema, so return details are optional. Description already covers returns. It is complete for a toggle tool, though no mention of prerequisites or side effects. With siblings, it stands alone well.

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 description must add meaning. It explains notebook_id as 'Notebook UUID' and is_public with default and effect. This adds value beyond the schema properties.

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 action: 'Enable or disable public link access.' This is a specific verb+resource that distinguishes it from sibling tools like notebook_share_status and notebook_share_invite.

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 (enable/disable public link) but lacks explicit guidance on alternatives or when not to use. Sibling tools exist for checking status or inviting by email, but 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?

No annotations are provided, so the description carries the full burden. It discloses return fields (is_public, access_level, collaborators, public_link) and implies a read-only operation, but does not mention permissions, rate limits, or other 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 extremely concise with no wasted words; purpose is front-loaded and every sentence adds value.

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 parameter, read-only) and the presence of an output schema, the description adequately explains the return values. It lacks mention of permission requirements but is otherwise 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?

With 0% schema description coverage, the description compensates by specifying 'Notebook UUID' for the single parameter, adding meaning beyond the raw 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 'Get current sharing settings and collaborators', which is a specific verb+resource. It differentiates from sibling tools like notebook_share_public (which sets sharing) and notebook_share_invite (which invites).

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 use to check current settings but provides no explicit guidance on when to use this tool versus alternatives or any conditions/prorequisites.

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, and the description does not disclose behavioral traits such as side effects (e.g., whether 'run' modifies data), authentication requirements, or rate limits. The term 'execute' implies mutation but lacks explicit safety warnings.

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 and well-structured: a single-sentence overview, bulleted actions, and a detailed args list. Every sentence adds value without redundancy or unnecessary elaboration.

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

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

While the description covers actions and parameters adequately, it lacks behavioral context (e.g., synchronous vs async, error handling) and does not leverage the existing output schema to explain return values. Given no annotations, more completeness is needed.

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 0% schema description coverage, the description compensates by explaining all four parameters: action (with values 'run' and 'list'), notebook_id (required for run), pipeline_name (with example 'ingest-and-podcast'), and input_url (replaces $INPUT_URL). This adds essential context beyond the bare 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 manages and executes multi-step notebook pipelines, with explicit actions 'run' and 'list' to further clarify scope. This distinguishes it from sibling tools like notebook_query or chat_list that handle different resources.

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 lists actions but provides no guidance on when to use this tool vs alternatives like notebook_query or source_list_drive. It does not specify prerequisites or when not to use it, leaving the agent to infer 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?

No annotations provided, so description carries full burden. It discloses that the tool reloads from disk and attempts re-authentication, and returns a status. However, it lacks details on side effects, failure modes, or what happens during re-authentication. Adequate but not thorough.

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 four sentences: first states action, second and third provide usage context, fourth describes return. No unnecessary words, well 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?

Given no parameters and only an output schema, the description covers purpose, use cases, and return value comprehensively. For a simple auth refresh tool, it provides sufficient context.

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 parameters, and schema description coverage is 100%. The description does not need to add parameter info. Baseline score of 4 applies as no parameter details are required.

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 action ('Reload auth tokens from disk or run headless re-authentication') and specifies distinct use cases (after `nlm login` or automatic re-authentication). It differentiates itself from sibling tools like `save_auth_tokens` by focusing on reloading and re-authentication.

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 states when to call the tool: 'Call this after running `nlm login` to pick up new tokens, or to attempt automatic re-authentication if Chrome profile has saved login.' Provides clear context, though no explicit when-not-to-use or alternative comparisons.

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 provided, but description discloses that cited_only overrides source_indices, timeout defaults to 300 seconds (increase for large notebooks). Does not mention if action is destructive or side effects, but adequate for a non-obvious 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?

Description is front-loaded with purpose and usage condition, followed by clear argument list. Every sentence adds value, no redundancy.

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

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

Covers all 5 parameters (2 required) with explanations, includes usage order, and references output schema (though not shown). Without annotations, provides sufficient completeness for invoking 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?

Schema description coverage is 0%, yet description explains each parameter: notebook_id, task_id, source_indices (default all), timeout (default 300, increase for large), cited_only (overrides source_indices). Adds meaning beyond schema's type info.

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 'import' and resource 'discovered sources into notebook'. It also provides context that it should be used after research_status shows completed, distinguishing it from other tools like source_add or note.

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 states when to call ('after research_status shows status="completed"'). Does not mention when not to use or alternatives, but the context is clear enough.

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 full burden. It discloses mode duration and source counts (fast ~30s, ~10 sources; deep ~5min, ~40 sources, web only), and explains that notebook_id creates a new notebook if omitted. It does not mention authentication, rate limits, or whether the operation is read-only, but the creation aspect is clear.

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

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

The description is well-structured with a summary line, usage examples, workflow, and parameter list. It is front-loaded with purpose. The Args section is clear but could be slightly tighter; however, it avoids unnecessary verbosity.

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 presence of an output schema (not shown but known), the description does not need to explain return values. It covers inputs, workflow, approximate outcomes, and the polling/import sequence, providing a complete picture 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?

Schema description coverage is 0%, so the description must fully explain parameters. It does so in the Args section, providing meanings for query, source, mode (with durations and source counts), notebook_id (optional, creates new), and title. This adds substantial value beyond the schema's default values and types.

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: 'Search web or Google Drive to FIND NEW sources.' It provides example use cases ('deep research on X', 'find sources about Y') and distinguishes from siblings by outlining the workflow (research_start -> research_status -> research_import).

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 lists explicit usage scenarios ('Use this for...') and the workflow implies when to use this tool versus research_status or research_import. However, it does not explicitly state when not to use this tool or provide alternative tools beyond the workflow chain.

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 full burden. It discloses blocking behavior, polling intervals, timeout, compact mode, and the auto_import side effect. It is transparent about key 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 front-loaded with the core purpose, then lists parameters clearly. It is not overly long, though the contributor credit is unnecessary but minor. Well-structured 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 complexity (7 params) and no annotations, the description covers all necessary details: blocking, polling, compact, auto_import interaction, and fallback matching. An output schema exists, so return value detail is not required.

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%, but the description explains all 7 parameters (notebook_id, poll_interval, max_wait, compact, task_id, query, auto_import) with clear meanings and defaults, fully compensating for the lack of schema descriptions.

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 'Poll research progress. Blocks until complete or timeout.' This is a specific verb+resource combination that distinguishes it from siblings like research_start, research_import, and notebook_query_status.

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?

While no explicit when-to-use/alternatives are given, the description implies usage for synchronous waiting and provides context for optional parameters like task_id and query, helping the agent understand its role in the research workflow.

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. It discloses fallback nature, deprecation, and auto-extraction but does not detail side effects (e.g., file writing, overwriting) or permissions needed, leaving some behavioral gaps.

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

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

The description is well-structured with bullet points and front-loaded purpose. Some redundancy (e.g., 'IMPORTANT FOR AI ASSISTANTS') but no wasted words.

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

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

Given the output schema exists and annotations are absent, the description covers all parameters, usage logic, and alternatives, making it complete for a fallback authentication tool.

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

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

Schema coverage is 0%, but the description adds detailed meaning: cookies source, deprecation, auto-extraction, and manual extraction conditions. This fully compensates for the missing schema descriptions.

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 saves NotebookLM cookies as a fallback method. It distinguishes from the preferred 'nlm login' command, making the purpose and context explicit.

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 instructs to try 'nlm login' first and only use this tool if CLI fails. Also notes deprecated parameters, guiding proper 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?

Despite no annotations, the description thoroughly explains behavioral traits: the multi-probe auth_check strategy, 30-second TTL caching, mtime-based bypass, and the meaning of each auth_status value. This goes beyond basic read-only 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 well-structured, front-loading the main purpose before detailing auth behavior. While it is lengthy, the detail is justified given the complexity of auth probing. A slightly more concise version could improve readability.

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

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

The description fully explains the return values (version info, auth_status meanings) and provides actionable guidance for AI assistants. Given that there are no parameters and an output schema exists, the description is complete and self-contained.

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

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

The tool has zero parameters, so schema coverage is effectively 100%. The baseline for no parameters is 4. The description does not need to add parameter info, and it correctly avoids redundancy.

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: 'Get server version, check for updates, and report auth status.' It uses a specific verb and resource, and the purpose is distinct from siblings like refresh_auth.

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 explicit guidance on how to use the output (e.g., inform user if update available, interpret auth_status meanings). However, it does not explicitly state when not to use this tool or contrast with alternatives like refresh_auth.

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 fully discloses behavior: wait options, file path restrictions (must be on MCP server), and image-bearing sources feeding video generation pipeline. No contradictions.

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?

Structured with bullets and examples, front-loaded with purpose. Slightly verbose but well-organized and easy to scan.

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

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

Given 11 parameters, 0% schema coverage, and no annotations, the description covers all aspects comprehensively, including return behavior via wait parameter and output schema existence.

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 has 0% coverage, but the description explains every parameter in detail (source_type options, url vs urls, file_path limitations, etc.), adding significant meaning beyond the schema.

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

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

Clearly states 'Add a source to a notebook' as a unified tool for all source types, with specific verb and resource. Easily distinguished from sibling tools like source_delete or source_describe.

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 detailed parameter descriptions and examples, covering various source types and usage patterns. No explicit exclusions, but the context makes it obvious when to use this tool versus alternatives (none exist for adding).

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 warns about the irreversible nature of the operation, which is critical behavioral information. With no annotations provided, it lacks details on authentication, rate limits, associated data destruction, or return value, but the output schema may address the latter.

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 and front-loaded, with every sentence earning its place. It first states the core action and its irreversible nature, then clearly outlines parameters.

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 3 parameters and no annotations, the description covers purpose, dual deletion modes, and safety requirements. It does not explain return values (output schema exists) or error conditions, but is largely complete for a delete operation.

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

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

Despite 0% schema description coverage, the description adds meaning by explaining source_id for single deletion, source_ids for bulk alternative, and confirm as a user approval requirement, going beyond schema types and defaults.

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 'Delete' and resource 'source(s)', and emphasizes the permanent and irreversible nature, distinguishing it from sibling tools like source_add, source_rename, and source_describe.

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 notes that confirm=True is required and explains the two deletion modes via source_id and source_ids. However, it does not explicitly specify when to use this tool versus alternatives, though siblings are contextually distinct.

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 bears full responsibility for behavioral clarity. It discloses that the summary is AI-generated and returns markdown with bold keywords, indicating a read-only, non-destructive operation. However, it does not explicitly state it is safe or mention any required permissions.

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 extremely concise, with a one-line purpose followed by labeled Args and Returns sections. Every sentence is informative, and the structure is front-loaded, allowing 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 and the presence of an output schema, the description adequately covers the key aspects: what it does, its input, and its return type. It could mention that it's read-only, but that is inferred from 'Get'. Overall, it is sufficient for a single-purpose describe 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 description adds semantic value to the single parameter 'source_id' by explaining it is a 'Source UUID', which goes beyond the schema's mere 'type: string'. Since schema coverage is 0%, this context is essential and well-provided.

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 'Get AI-generated source summary with keyword chips', specifying the verb 'Get' and the resource 'source summary'. This distinguishes it from sibling tools like 'source_add' or 'source_delete', which are for adding or deleting sources.

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

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

The description implies usage when needing a source summary, but it does not explicitly state when to use or avoid this tool compared to alternatives. It provides no exclusions or alternative tool suggestions, relying on the tool name for differentiation.

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 provided, so description carries full burden. It explains it returns raw text without processing and lists output fields. Does not cover error cases or authentication needs, but adequately describes behavior for a simple read operation.

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

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

Two clear sentences in first paragraph for purpose, then structured args/returns. Front-loaded and efficient, though the 'Returns' line could be integrated.

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 tool simplicity and presence of output schema, description covers main functionality, source types, and speed comparison. Lacks error handling details but is sufficient for a straightforward retrieval tool.

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

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

Only parameter source_id is described as 'Source UUID', which is merely restating the parameter name. Schema coverage is 0%, and description adds no additional semantic value beyond the schema.

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

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

Description clearly states the tool retrieves raw text content from sources (PDFs, web pages, etc.) with no AI processing. It explicitly distinguishes from sibling notebook_query by noting speed advantage for content export.

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 guidance for when to use (exporting raw content, speed priority) and compares to a sibling. Lacks explicit when-not-to-use or alternative tools beyond notebook_query.

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 provided, so description carries full burden. Describes the listing nature and skip_freshness parameter effect. Implies read-only (no mutation). Could explicitly state it's a read operation, but sufficient for a list 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?

Two concise sentences plus parameter list. No unnecessary words. Front-loaded with 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?

Given output schema exists, description need not detail return values. Covers purpose, usage, and parameter meaning adequately. Could elaborate on 'freshness status' but not essential.

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 description must compensate. Explains skip_freshness effectively ('skip per-source freshness checks for faster listing'). Description for notebook_id is minimal ('Notebook UUID'), repeating type but adding no context. Partially compensates.

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?

Clearly states it lists sources with types and Drive freshness status, and explicitly links to source_sync_drive as a precursor. Differentiates from sibling tools by specifying its role in identifying stale sources.

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 explicit usage: 'Use before source_sync_drive to identify stale sources.' This tells when to use. Does not mention when not to use, but the context and sibling tool list imply it's for listing only.

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

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

No annotations are provided, so the description alone must disclose behavior. It states 'rename' (mutation) but does not mention side effects, permissions, reversibility, or error handling. The existence of an output schema is acknowledged but not described.

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: a single sentence stating the purpose followed by a structured parameter list. It is front-loaded with the main action, but the parameter list is slightly redundant with the schema, though it adds context.

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

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

For a simple rename tool, the description covers purpose and parameters minimally but misses behavioral context (idempotency, failure modes, return type) and prerequisites (e.g., existence of notebook/source). The output schema exists but is not leveraged to describe the response.

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 adds value by naming parameters and giving brief explanations (e.g., 'Notebook UUID containing the source'). However, it lacks details on constraints (e.g., title length limits, UUID format) and does not explain the meaning beyond what is obvious from the 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 clearly states the verb 'Rename' and the resource 'source in a notebook', distinguishing it from sibling tools like source_add, source_delete, and source_describe. It specifies the context and action concisely.

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

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

No guidance on when to use this tool versus alternatives (e.g., source_add for adding, source_delete for removing). No prerequisites or exclusion conditions are mentioned, leaving the agent to infer usage without direction.

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 provided, so description carries full burden. It discloses the confirmation requirement (confirm=True) which implies a safety check. Does not mention potential side effects like overwriting, but the confirmation hint addresses the primary behavioral concern.

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

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

Three short sentences, each with distinct value: main action, prerequisite, parameter details. No wasteful words; front-loaded with 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?

Given the presence of an output schema and clear parameter explanations, the description is nearly complete. Minor gap: no mention of what happens during sync (e.g., rate limits or idempotency), but overall adequate.

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

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

With 0% schema coverage, the description fully compensates by explaining both parameters: 'source_ids: Source UUIDs to sync' and 'confirm: Must be True after user approval', adding crucial meaning beyond the schema types.

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 'Sync Drive sources with latest content' which is a clear verb+resource. It distinguishes from sibling 'source_list_drive' which lists sources rather than syncing 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?

Explicitly says to 'Call source_list_drive first to identify stale sources' and notes that 'Requires confirm=True', providing clear context and 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?

With no annotations, the description carries the full burden and does disclose non-obvious behavior: the human-approval gate on confirm, the default-all-sources behavior, and the subtle side effect where orientation='portrait' silently auto-prepends a TikTok 9:16 directive to focus_prompt with de-duplication. It does not say whether creation is synchronous or job-based, but the disclosed edge cases go well 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?

Front-loaded with purpose followed by grouped args, type-specific options, common options and a caveat note, then examples. Given 22 parameters this length is justified, though the opening 'Unified creation tool' line restates the first sentence, and some spacing/indentation is inconsistent.

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 22-parameter tool with an output schema (so return values needn't be described), the definition covers required args, per-type options, common options, defaults, the language env-var fallback, and the slide-deck orientation workaround. Nothing an agent needs to invoke 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 description coverage is 0% and no enums are declared in the schema, so this description is doing all the work — and it does it: every parameter is documented and the allowed values for audio_format, visual_style, infographic_style, slide_format, difficulty, report_format and the rest are enumerated here and nowhere else. This is exactly the case where the description must compensate, and it does so fully.

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 ('Create any NotebookLM studio artifact. Unified creation tool') and lists the nine artifact types it covers. This cleanly separates it from siblings like studio_revise, studio_status and studio_delete, which an agent can distinguish without opening any schema.

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

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

Provides usage context through the confirm gate ('Must be True after user approval') and the source_ids default ('all sources'), plus two worked examples. However, it never states when to use this vs studio_revise or studio_delete, nor under what circumstances creation should be declined, leaving the create-vs-modify routing 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?

Discloses critical behavior: 'IRREVERSIBLE' and 'Requires confirm=True.' With no annotations, the description fully informs the agent about the destructive nature and confirmation requirement.

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?

Concise and well-structured: a brief header with warning, followed by a bulleted list of arguments. No superfluous text; every sentence adds value.

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 purpose, usage, parameters, and behavioral traits adequately. An output schema exists, so return values are not needed. Could mention prerequisites like user permissions, but overall complete for a delete tool.

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

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

Schema description coverage is 0%, but the description provides detailed explanations for each parameter: notebook_id is Notebook UUID, artifact_id is Artifact UUID (from studio_status), and confirm must be True after user approval.

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 explicitly states 'Delete studio artifact' using a specific verb and resource. It distinguishes from siblings like notebook_delete and source_delete by specifying 'studio artifact.'

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 guidance: it warns of irreversibility and requires confirm=True. It also references artifact_id from studio_status. However, it lacks explicit when-not-to-use or comparison with alternatives.

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

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

No annotations are provided, so the description carries the full burden. It reveals key behavioral traits: creates a new artifact (original unchanged), asynchronous (poll studio_status), requires confirmation (confirm=True). The existence of an output schema compensates for missing 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 concise, well-structured with an Args section and example. Every sentence provides useful information without redundancy. It is appropriately front-loaded with 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?

With an output schema present, the description does not need to explain return values. It covers purpose, parameter details, usage flow (async polling, confirmation), and constraints (only slide decks). It is complete for a revision 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 input schema has 0% description coverage, but the description explains each parameter thoroughly, especially slide_instructions with structure, examples, and the confirm parameter's semantics. This adds significant meaning beyond the schema.

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

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

The description clearly states the action ('Revise individual slides') and the resource ('existing slide deck'). It distinguishes from siblings like studio_create and studio_status by emphasizing that it creates a new artifact and requires polling. The verb and resource are specific.

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: only slide decks support revision, and users should poll studio_status after calling. It does not explicitly state when not to use it, but the context and siblings imply it is the appropriate tool for revisions.

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 provided, so the description covers actions and return structures. However, it does not explicitly disclose that rename is a mutation, lacks warnings about side effects, and omits rate limits or permission requirements.

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

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

The description is concise with a clear opening sentence, parameter details, and return structure. Every sentence serves a purpose, though it could be more structured (e.g., separate sections for actions).

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 scope (status and rename) and presence of output schema, the description covers actions, parameters, and return format adequately. Missing error cases or prerequisites but still 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?

With 0% schema description coverage, the description compensates by explaining each parameter's role, valid values for action (status, rename, list_types), and conditions (artifact_id and new_title required for rename). Adds significant meaning beyond 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 it checks studio content generation status and renames artifacts, using specific verbs. It distinguishes from sibling tools like studio_create, studio_delete, studio_revise by focusing on status and rename 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 explains actions and their requirements but does not explicitly guide when to use this tool vs alternatives (e.g., research_status for research, studio_create for creation). Users must infer usage from 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?

No annotations are provided, so the description must fully disclose behavioral traits. It outlines actions and required parameters but does not mention side effects (e.g., consequences of adding duplicate tags), idempotency, or authentication requirements, leaving gaps for safe invocation.

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 well-structured with a purpose statement followed by bullet lists for actions and parameters. It is mostly concise, though some parameter examples could be trimmed without loss of clarity.

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 5 parameters, no annotations, and an output schema exists, the description covers input well but does not explain return values or pagination. It is adequate but leaves some behavioral context unaddressed.

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

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

Schema description coverage is 0%, but the description adds full meaning for all parameters: action, notebook_id, tags (with comma-separated example), notebook_title, and query (with example). It specifies which parameters are required for which actions, significantly enhancing 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 manages notebook tags and finds relevant notebooks via tag matching. It lists specific actions (add, remove, list, select) and differentiates from siblings like notebook_query which are about querying content rather than tags.

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 via actions but does not explicitly guide when to use this tool versus alternatives like notebook_query or cross_notebook_query. It lacks when-not or alternative recommendations.

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