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 full burden. It discloses authentication requirements, potential 400/401 errors, and the return dictionary structure. However, it doesn't mention whether switching modes affects current session state beyond auth.

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 an IMPORTANT section, bullet points, and clear Args/Returns. It is concise yet comprehensive, with 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 complexity of authentication modes and three parameters, the description covers auth, parameters, and return value. It lacks details on error handling beyond auth errors, but overall completes the picture.

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 adds meaning for all three parameters: mode (personal/enterprise), project_id (required for enterprise, source), location (default global). It clarifies constraints not in 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 explicitly states it configures NotebookLM mode (personal or enterprise), which is a specific verb-resource pair. It distinguishes from siblings like refresh_auth or save_auth_tokens by focusing on mode switching.

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 authentication prerequisites and warns about errors when switching modes. It doesn't list alternative tools for similar tasks but gives clear context for when to use this tool.

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

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

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?

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?

With no annotations, the description must disclose behavioral traits. It mentions the return dictionary with operation name for tracking/downloading, hinting at async behavior, but does not explicitly state that the operation is asynchronous or requires polling. It also omits potential side effects 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 concise, front-loading the purpose and then listing parameters with clear explanations. 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?

Given the output schema exists (though not shown), the description adequately covers parameter semantics and return structure. It could be improved by clarifying the async nature and integration with podcast_download, but overall it is sufficiently complete.

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

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

Schema coverage is 0%, so the description must compensate. It explains each parameter: text (string or list), title, description, focus, length (SHORT/STANDARD), and language (default en). This adds meaning beyond the schema, though the focus parameter could be clearer.

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: 'Generate a standalone podcast from text (Enterprise only, no notebook needed).' It specifies the verb (generate), the resource (podcast), and the Enterprise constraint, distinguishing it from sibling tools like podcast_download.

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 'Enterprise only' and 'no notebook needed', implying usage conditions, but it does not explicitly state when to use this tool versus alternatives like podcast_download or studio_create. No exclusion criteria are provided.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states that the tool downloads a file, with a default output path, but omits critical details such as whether overwriting occurs, network dependencies, timeout behavior, or error handling for missing operations.

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 clear one-line purpose followed by structured Args and Returns sections. Every sentence is useful and front-loaded with the action.

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

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

Given a simple download tool with an output schema, the description covers the basic function and parameters. However, it lacks details on synchronous/asynchronous execution, error handling, and potential side effects, making it adequate but not fully complete.

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

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

Schema coverage is 0%, so description must compensate. It explains that operation_name comes from the podcast_create response and notes the default output path for output_path, adding meaningful 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 verb 'Download' and the resource 'completed standalone podcast', which is distinct from the sibling podcast_create tool. It immediately conveys the tool's core function.

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 mentions 'operation_name from podcast_create response', indicating this tool is used after creation. However, it does not explicitly exclude other download tools like download_artifact or provide when-not-to-use guidance, which would justify a 5.

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

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

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, so description carries full burden. It mentions the action and parameters, includes default behavior for source_indices and timeout. However, it does not disclose side effects (e.g., whether import adds or overwrites), error behaviors, or prerequisites beyond the status condition. Useful but 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 extremely concise: two lines of purpose, one usage precondition line, and a clean Args list. Every sentence serves a purpose, no filler. Front-loaded with purpose and usage, then structured param details.

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

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

Purpose, usage, and parameters are well-covered. The existence of an output schema mitigates the need to describe return values. However, it lacks details on error handling, success confirmation, or what modifications occur to the notebook. For a workflow step, it is largely sufficient.

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

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

Schema description coverage is 0%, but the 'Args' section in the description compensates fully. It explains each parameter's type (UUID, ID, indices, seconds), defaults (source_indices: all, timeout: 300), and guidance (increase for large notebooks). This adds significant meaning 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's purpose: 'Import discovered sources into notebook.' It uses a specific verb ('import') and resource ('sources into notebook'), distinguishing it from siblings like research_start and research_status by implying it is the post-completion step.

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: 'Call after research_status shows status="completed".' This provides a clear precondition. It also offers usage advice on timeout for large notebooks. Lacks mention of alternatives or when not to use, but the precondition is strong.

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

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

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?

Discloses blocking behavior, timeout defaults, compact mode token saving, and fallback matching. No annotations to contradict. Missing potential side effects like rate limits or cancellation behavior.

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

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

Single line summary then clear parameter list. No superfluous text. Efficiently conveys all necessary information in a structured format.

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, the description covers purpose, blocking, timeout, compact mode, and task-specific polling. Complete for a polling tool without needing to describe return format.

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 explains every parameter: notebook_id, poll_interval, max_wait, compact, task_id, query. Provides defaults, meaning, and even credits a contributor. Adds significant value.

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 polls research progress and blocks until complete or timeout. Distinguishes from siblings like research_start (which starts research) and notebook_query_status (which is for notebook queries).

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?

Implies usage: when you need to wait for a research task to finish. Provides parameter details but lacks explicit when-not-to-use or alternatives. Could mention that research_start should be called first.

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?

No annotations are provided, so the description must carry the full burden. It mentions return type but does not disclose behavioral traits such as authentication requirements, side effects, 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 extremely concise with two sentences, no redundant information, and the most important detail (what it returns) 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 the simplicity of the tool (0 parameters, output schema exists), the description is adequate but lacks details like authentication necessity or whether it can be called frequently. Slightly incomplete for a context-dependent 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 tool has no parameters, and schema coverage is 100%. The description adds minimal value but correctly states the return content. Baseline for 0 params is 4.

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 'Get' and the resource 'server version, mode, and auth status', making the purpose straightforward. However, it does not differentiate from sibling tools, but none seem to overlap significantly.

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 like refresh_auth or configure_mode. The description lacks context on prerequisites or typical 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?

With no annotations, the description carries full burden. It discloses paywall/login check, wait behavior, and bulk URL support. Not mentioning error handling or permissions, but sufficient for typical usage.

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?

Well-structured: one-line purpose, supported types, special behavior, Args list, then examples. Every sentence adds value, 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?

Comprehensive for a tool with 12 parameters and multiple source types. Covers all parameter semantics, special behaviors (paywall, wait, bulk), and provides examples. Output schema exists to cover return values.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It provides a detailed Args section for each of the 12 parameters, including types, dependencies on source_type, and default values.

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 'Add a source to a notebook' with 'Unified tool for all source types', using specific verb+resource and differentiating from sibling tools like source_delete, source_describe, etc.

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 lists supported source types (url, text, drive, file) and provides guidance on paywall check behavior, including when to skip. Does not explicitly contrast with sibling tools like source_list_drive or source_sync_drive, so not perfect.

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 are provided, so the description carries full responsibility. It mentions returning 'types and Drive freshness status' but does not disclose whether the tool is read-only, what 'freshness status' specifically entails (e.g., timestamps), or any authorization needs. The parameter notebook_id is not explained as scoping to a specific notebook's sources.

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

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

The description is concise with two sentences plus a parameter line. It is front-loaded with the main purpose, contains no superfluous text, and is easy to parse.

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

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

Given the tool has one parameter and an output schema (not provided), the description is adequate but minimally detailed. It does not explain that sources are listed for a specific notebook, leaving room for ambiguity. For an agent, clearer scoping would improve decision-making.

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

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

The schema has 0% description coverage and only one required parameter. The description adds 'Notebook UUID' which is minimal and largely redundant with the parameter name. It does not explain the parameter's role in scoping the list or any constraints, leaving the agent to infer its purpose.

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 'List' and the resource 'sources' with specific return information ('types and Drive freshness status'). It distinguishes itself from sibling tools like source_sync_drive and source_describe by focusing on listing all sources with freshness metadata.

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 advises to use this tool before source_sync_drive to identify stale sources, providing clear workflow guidance. This effectively contextualizes when to invoke the tool.

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

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

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?

No annotations are provided, so the description carries the full burden. It discloses the required confirm parameter (must be True after user approval) and type-specific options. However, it doesn't mention whether creation is synchronous or asynchronous, or what the output format is (output schema exists).

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 long but well-structured with sections for args, type-specific options, common options, and examples. It front-loads the main purpose. Could be slightly more concise, but the structure aids 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 high complexity (22 params, no annotations) and the presence of an output schema, the description does a good job covering creation behavior. It provides examples and explains type-specific parameters. It doesn't cover error handling or return values, but those may be in the output schema.

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

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

Schema description coverage is 0%, but the description adds extensive meaning for each parameter, especially artifact_type and type-specific options. It provides detailed explanations, defaults, and valid values for all 22 parameters.

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

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

The description clearly states it is a unified creation tool for NotebookLM studio artifacts, lists all supported artifact types, and provides examples. It distinguishes itself from sibling tools like studio_delete and studio_revise.

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 usage context for creating any studio artifact and includes example calls. It does not explicitly state when not to use this tool or mention alternatives, but the breadth of supported types makes it 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?

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 description shoulders full burden. It details actions and return values for status, but for the rename mutation, it does not disclose potential side effects, reversibility, or required permissions. Error behavior for invalid inputs is not 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?

Description is structured with Args and Returns sections, front-loading the main purpose. While clear, the Returns section repeats information likely present in the output schema, adding minor redundancy. 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?

Covers all actions, parameters, and return structure despite complexity (4 params, multiple actions). Output schema exists but description supplements it. Lacks error handling or prerequisite info, but adequate for core functionality.

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 fully explains each parameter: notebook_id as UUID, action with three enumerated values, and conditional parameters artifact_id and new_title for rename. This adds essential context missing from 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 explicitly states the tool checks studio content generation status and can rename artifacts. It lists three actions (status, rename, list_types) with clear resources (studio artifacts). This distinguishes it from sibling tools like research_status or notebook_query_status which handle different domains.

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

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

The description implies usage through parameter explanations and action options, but does not explicitly state when to use this tool versus alternatives (e.g., research_status for research artifacts). No guidance on prerequisites or when not to use.

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

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

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.