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

The description notes that delete is irreversible and requires confirm=True, but does not disclose behaviors for other actions (e.g., whether they are reversible, auth needs, or side effects). With no annotations provided, more behavioral detail would be beneficial.

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 reasonably concise with an introductory sentence and bullet-style list. It front-loads the purpose. Some redundancy could be trimmed (e.g., repeating action list in args), but overall well-structured.

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

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

Given the complexity (9 parameters, batch operations), the description covers actions and parameters adequately. Since an output schema exists, return values need not be explained. However, it could mention atomicity, error handling, or confirmation behavior beyond delete.

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 explains each parameter's purpose and context (e.g., 'query: Question to ask (for action=query)'). It provides examples for artifact_type and clarifies notebook_names. However, the required 'action' parameter lacks a list of accepted values (though implied by actions list).

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 performs batch operations across multiple notebooks and lists specific actions (query, add_source, create, delete, studio). This clearly distinguishes it from sibling tools that operate on single notebooks.

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 available actions but does not provide guidance on when to use batch vs individual tools (e.g., batch delete vs notebook_delete). It lacks explicit when-to-use or when-not-to-use instructions.

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 does not disclose any behavioral traits such as side effects, authorization requirements, or whether the operation is idempotent. The name implies mutation, but no explicit confirmation.

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

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

The description is brief and lists parameters clearly. It front-loads the purpose. However, the format is somewhat mechanical and could be more natural without losing 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 that an output schema exists, return values are not needed. However, the description lacks contextual completeness such as when to configure chat settings, any preconditions, or behavioral implications. It is adequate but has gaps.

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

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

Schema description coverage is 0%, so the description compensates by detailing allowed values for goal and response_length, the conditional requirement for custom_prompt, and the max length. This adds meaning beyond the schema which only provides 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 'Configure notebook chat settings', which is a specific verb+resource. It distinguishes from sibling tools like notebook_query or configure_mode by its focus on chat 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 this tool versus alternatives. No exclusion criteria or prerequisites mentioned, leaving the agent without context for appropriate invocation.

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 must cover behavioral traits. It mentions rate limits and aggregated citations, but does not disclose whether the tool is read-only, authentication requirements, or error behavior. This is insufficient for a cross-notebook query tool.

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

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

The description is concise (~80 words) and well-structured. It starts with a clear one-line summary, then lists arguments in a bullet-like format with 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 complexity (cross-notebook query) and the presence of an output schema, the description adequately covers input selection methods and gives a sense of the output (aggregated answers with citations). It does not detail the output format, but the output schema handles that.

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

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

Schema description coverage is 0%, meaning the schema has no parameter descriptions. The tool description compensates by explaining each parameter: query as 'Question to ask across notebooks', notebook_names as 'Comma-separated notebook names or IDs', tags as 'Comma-separated tags', all as 'Query ALL notebooks'. This adds significant meaning beyond the bare 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 'Query multiple notebooks and get aggregated answers with per-notebook citations.' It specifies the verb (query), resource (multiple notebooks), and output (aggregated answers with citations). This differentiates it from sibling tools like '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 provides three selection methods (by name, tags, all=True) and warns about rate limits for all=True. While it gives good context on when to use each option, it does not explicitly compare to alternatives like 'notebook_query' for single notebook queries.

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?

Without annotations, the description explains the download behavior, parameters, return value, and examples. It covers what the tool does but does not mention authorization needs, rate limits, or side effects, though the operation is 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 well-structured with Args, Returns, and Examples. It is comprehensive but slightly lengthy; some bullet points could be condensed without losing 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?

The description covers all parameters, return values, and provides examples. Minor gaps: does not explain what happens when artifact_id is omitted (uses latest) and lacks error handling details.

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

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

The description compensates for 0% schema description coverage by providing detailed explanations of each parameter, including valid artifact types, optional fields, and format choices. 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 the tool downloads any NotebookLM artifact to a file, listing all supported types. It is unified, replacing 9 separate tools, and distinct from siblings like podcast_download and export_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 positions itself as the unified download tool, implying use for all listed artifact types. However, it does not explicitly state when to use alternatives or when not 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?

With no annotations, the description must carry the full burden of behavioral disclosure. It only mentions the export action and return URL, but omits critical details like side effects (e.g., does it modify the artifact?), authentication requirements, or error conditions.

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 bullet points and clear sections. It front-loads the main purpose and provides argument details efficiently.

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

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

The description covers parameters and return value (URL), but lacks context on preconditions (e.g., artifact existence) and postconditions (e.g., no modification to source). Given the tool's complexity and 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?

Input schema has 0% description coverage, so the description adds essential meaning: it explains notebook_id, artifact_id, export_type (implied values 'docs' and 'sheets'), and title as optional. This compensates well 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 clearly states the tool exports a NotebookLM artifact to Google Docs or Sheets, and distinguishes between exporting Data Tables to Sheets and Reports to Docs. This provides specific verb+resource+target differentiation from siblings 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 includes basic usage guidance by mapping artifact types to export formats (Data Tables → Sheets, Reports → Docs) and listing required arguments. However, it doesn't explicitly compare to other tools or state when not to use it.

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

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

Discloses that delete requires confirm=True and is permanent; no annotations exist, so description carries full burden. Lacks details on auth or rate limits but covers core behaviors.

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-organized with actions described in bullet points, clear examples, and no redundant sentences. Efficiently conveys all necessary information.

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 6 parameters, all actions, provides examples, mentions return type, and is complete given the existence of an 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 has no descriptions (0% coverage). The description explains every parameter in detail, including conditional requirements and example values, fully compensating for the schema gap.

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

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

The description clearly states 'Manage notes in a notebook' and lists all supported operations (create, list, update, delete), making the tool's purpose explicit and distinct from sibling tools.

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

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

Provides examples and specifies when each action is appropriate, but does not explicitly mention when to avoid this tool in favor of alternatives, though no direct competitors exist among 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?

No annotations provided, and the description does not disclose any behavioral traits beyond creation. It does not mention side effects, return value, or 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 concise but lacks structure such as examples or usage patterns. For a simple tool, it is adequately sized, but could be more structured.

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

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

Given the tool's simplicity and existence of an output schema, the description covers the basics. However, it misses contextual details like what the response contains or how to handle errors.

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; the description adds that 'title' is optional, which is not in the schema. However, it does not elaborate on format or constraints.

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 'Create a new notebook', which is a specific verb and resource. This distinguishes it from sibling tools like notebook_delete or notebook_list.

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, nor any prerequisites or limitations. The agent has no context to decide if this is appropriate.

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 clearly states the action is permanent and irreversible, and that confirm must be true. This covers the key behavioral traits for a delete tool, though could mention effects on shared access.

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: two sentences plus argument list. Front-loaded with the critical behavior 'Delete notebook permanently. IRREVERSIBLE.' 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 simplicity of a delete tool with output schema, the description covers the essential behavior and parameter requirements. Could optionally mention return value or error cases, but not necessary for 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?

Schema coverage is 0%, so description must compensate. It adds meaning by describing notebook_id as 'Notebook UUID' and confirm as 'Must be True after user approval'. This is basic but sufficient; could elaborate on UUID format or how to obtain it.

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

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

The description clearly states 'Delete notebook permanently' with 'IRREVERSIBLE', specifying the verb and resource. It distinguishes from sibling tools like notebook_create or notebook_rename by emphasizing permanence.

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 requires confirm=True after user approval, guiding proper invocation. Lacks explicit when-not-to-use or alternatives, but the confirmation requirement effectively communicates the safety gate for a destructive operation.

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

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

With no annotations provided, the description carries full burden. It implies a read-only operation but does not disclose whether it caches results, requires authentication, or has any side effects. The AI-generated aspect hints at computational cost but is 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?

The description is extremely concise with no wasted words. It front-loads the purpose and efficiently lists arguments and returns.

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 single parameter and an existing output schema, the description covers the essential return format (summary markdown, suggested_topics list). It is adequate for a simple describe tool, though it lacks details on error handling or limitations.

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 meaning to the single parameter by specifying it is a 'Notebook UUID', beyond the schema's mere string type. With 0% schema description coverage, the description compensates well.

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

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

The description clearly states the tool's purpose: get an AI-generated notebook summary with suggested topics. It uses a specific verb-resource combination and distinguishes itself from siblings like notebook_get (raw content) and notebook_list (listing).

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

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

No guidance is provided on when to use this tool versus alternatives such as notebook_get or notebook_query. There are no prerequisites, exclusions, or alternative tools mentioned.

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

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

With no annotations, the description must disclose behavioral traits. It only states the operation is 'get', implying read-only, but does not mention permissions, rate limits, or what 'details' and 'sources' encompass.

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 short (two lines) and front-loaded, but it may be too sparse. It sacrifices clarity for brevity, offering no structure beyond a single argument note.

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 single parameter and an existing output schema, the description is minimally adequate for a simple retrieval tool. However, it omits details about what 'sources' entails and potential edge cases.

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

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

Schema description coverage is 0%, so the description must compensate. It adds only 'Notebook UUID' to the parameter name, which is minimal; it does not explain how to obtain the ID or validate the format.

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 'Get notebook details with sources', which clearly specifies the action and resource. However, it does not differentiate from the sibling tool 'notebook_describe', which likely performs a similar retrieval.

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 like notebook_describe or notebook_list. The description lacks context for the agent to decide.

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

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

With no annotations provided, the description carries full burden. It implies a read-only operation but does not disclose behavior like result limits beyond max_results, pagination, or authentication needs. It is minimally adequate.

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—one sentence and a parameter definition. No wasted words, and the purpose is front-loaded. It earns its place.

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

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

While an output schema exists (reducing the need to describe returns), the description lacks details on scoping (e.g., all notebooks vs. user-accessible), ordering, or the possibility of empty results. It is sufficient but not comprehensive.

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% coverage, but the description explains 'max_results: Maximum number of notebooks to return (default: 100)', adding meaning beyond the schema's type and default. This 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 'List all notebooks' uses a specific verb and resource, clearly distinguishing from sibling tools like notebook_create, notebook_delete, and notebook_query. It is unambiguous about what the tool does.

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

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

There is no guidance on when to use this tool versus alternatives such as notebook_query (filtered list) or notebook_get (single notebook). The description provides no context about appropriate use cases or exclusions.

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

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

No annotations are provided, so the description carries full burden. It explains that the tool queries existing sources but does not explicitly state it is read-only or non-destructive. While implied, a more explicit statement about safety would improve transparency. The parameter details (e.g., timeout default) add 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 highly concise: two short introductory sentences followed by a structured parameter list. Every sentence earns its place—no redundancy, clear separation of purpose, usage, and parameter docs.

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 (no need to explain return values) and 5 parameters, the description covers all necessary context: purpose, when to use vs. alternatives, and parameter semantics. It also mentions environment-based defaults, making it complete for a query 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 compensates fully by explaining all 5 parameters in the Args section, including defaults and purpose (e.g., source_ids defaults to all, conversation_id for follow-ups, timeout from env). 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: 'Ask AI about EXISTING sources already in notebook.' It uses a specific verb and resource, and explicitly distinguishes from finding new sources, setting it apart from siblings like research_start.

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

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

The description provides explicit guidance on when not to use this tool ('NOT for finding new sources') and suggests an alternative: 'Use research_start instead for: deep research, web search, find new sources, Drive search.' This is excellent contextual advice.

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

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

No annotations are present, so the description carries full burden. It discloses that the tool is asynchronous, returns immediately with a query_id, and requires polling. It also explains the timeout behavior. However, it does not mention any side effects or error conditions, which prevents a perfect score.

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

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

The description is concise and well-structured: first sentence sets purpose, second provides selection guidance, third describes return, fourth gives workflow, then Args. 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 async workflow and sibling tools (notebook_query, notebook_query_status), the description fully explains the usage lifecycle. It covers when to use, what it returns, and how to get results. No gaps for an agent to infer.

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

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

Schema coverage is 0%, so the description must compensate. It explains each parameter's purpose and defaults (e.g., source_ids default 'all', timeout default from env or 120.0). This adds significant meaning beyond the bare 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 clearly states it starts an asynchronous query for large notebooks that may timeout. It explicitly distinguishes itself from the sibling tool notebook_query by specifying the condition (many sources, >60s). The verb 'start' and resource 'notebook query' 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 explicitly says 'Use this instead of notebook_query when querying notebooks with many sources (50+) where the response may take longer than 60 seconds.' It also provides a clear workflow: start -> poll status. This gives excellent guidance on when and how 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 provided. Description states it returns result or status, implying it is a read-only polling operation. It does not discuss idempotency or side effects, but given the nature, it is minimally 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?

Two sentences plus a parameter list. Front-loaded with purpose and usage instruction. No unnecessary words. Highly 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 presence of an output schema (not shown), the description does not need to detail return values. It covers purpose, parameter, and polling advice. Could mention possible status values, but adequate 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?

The single parameter query_id is described as 'The query ID returned by notebook_query_start', adding essential context beyond the schema's type-only definition. Schema coverage is 0%, so description compensates well.

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 checks the status of an async notebook query (verb 'check', resource 'status'). It references the companion tool notebook_query_start, distinguishing it from sibling tools like 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?

Explicitly says to poll every few seconds until completed or error, and that the query must have been started with notebook_query_start. Does not mention when not to use or alternatives, but context 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. Description does not disclose behavioral traits such as idempotency, error conditions, or constraints on renaming (e.g., duplicate titles).

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: two sentences plus arg list. No wasted words. Main action 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?

Output schema exists, so return values are covered. However, lacks details on error handling, side effects, or prerequisites, leaving gaps for a simple rename 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%; description merely restates parameter names with minimal context ('Notebook UUID', 'New title'). Does not add meaning beyond what the schema field types imply.

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

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

Clear verb 'rename' and resource 'notebook' explicitly stated. Distinct from sibling tools like notebook_create or 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 notebook_describe or notebook_get. No mention of prerequisites or limitations.

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?

Without annotations, the description discloses the important behavioral requirement that 'confirm must be True after user approval'. However, it does not discuss idempotency, whether it overrides existing permissions, or other side effects.

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 and Returns sections and a front-loaded purpose. It is slightly verbose but all sentences add value; could be more concise without losing 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 there is an output schema, the description adequately covers parameters and return values. It lacks details on error conditions or prerequisites, but for a batch invite tool, the core functionality is sufficiently described.

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 compensates fully: it explains notebook_id, recipients (with structure, example, and role default), and confirm (with required value). This adds significant 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 'Invite multiple collaborators in a single request,' using a specific verb and resource. It implicitly distinguishes from the sibling tool notebook_share_invite, which likely handles single 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 batch usage by mentioning 'in a single request' and requiring 'confirm: Must be True after user approval'. However, it does not explicitly state when to use this tool over alternatives or provide exclusion criteria.

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 for behavioral disclosure. It states the action and return value but omits details such as authentication requirements, whether an email is sent, rate limits, or side effects.

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

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

The description is brief and efficient, with a clear purpose statement followed by a structured Arg block. 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?

Despite lacking annotations and having 0% schema coverage, the description covers the essential aspects: action, parameters, and return value ('Returns: success status'). The presence of an output schema (not shown but indicated) supplements the return description. Minor gap: no mention of failure conditions.

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 meaning beyond the JSON schema by explaining `email` as 'Email address to invite' and `role` as '"viewer" or "editor" (default: viewer).' Even though schema coverage is 0%, this commentary clarifies parameter 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 'Invite a collaborator by email,' specifying the verb (invite) and resource (collaborator via email). Among siblings, there are `notebook_share_batch` and `notebook_share_public`, making this distinct.

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 (to invite a collaborator by email) but provides no explicit guidance on when to use this tool versus alternatives like `notebook_share_batch` or `notebook_share_public`. No exclusions or when-not-to-use context 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?

With no annotations, the description tells the tool toggles public access and returns a link (or None), which is transparent about the basic behavior. However, it lacks details on permissions needed, idempotency, or side effects (e.g., what happens if already enabled). This is adequate for a simple toggle but not fully rich.

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 zero wasted words. The action is front-loaded, and the structure (Args/Returns) is clear and efficient. Every sentence earns its place.

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

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

Given the tool's simplicity (two parameters, toggle operation, output schema exists), the description covers the core behavior well. It could optionally mention error conditions (e.g., invalid notebook_id) but is otherwise complete for an agent to 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?

Despite 0% schema coverage, the description thoroughly explains both parameters: notebook_id is a UUID, is_public defaults to True and toggles the link. This adds substantial meaning beyond the raw schema, including a clear use case for each 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 'Enable or disable public link access,' which is a specific verb-resource pair. It distinguishes from sibling tools like notebook_share_invite (for individual invites) and notebook_share_batch (for bulk operations) by focusing solely on public link toggling.

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 public link sharing but does not explicitly state when to use this tool versus alternatives (e.g., notebook_share_invite for specific users). No exclusion or context for when not to use is provided, leaving the comparison implicit.

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 structure (is_public, access_level, collaborators, public_link) and implies a read-only operation via the verb 'get'. Additional details about side effects or authorization would improve clarity.

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 front-loaded sentence specifying the tool's purpose, followed by structured parameter and return descriptions. 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 simplicity (one parameter, read operation, output schema exists), the description adequately covers what the tool does, what it returns, and the input required. No additional context is necessary for an agent to use it correctly.

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

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

The description adds meaning to the single parameter 'notebook_id' by indicating it is a 'Notebook UUID', which is not present in the input schema (0% schema coverage). However, it does not elaborate on format or constraints, but for a single UUID parameter this is sufficient.

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 ('Get') and clearly identifies the resource ('current sharing settings and collaborators'), distinguishing it from sibling tools like notebook_share_invite and notebook_share_public that modify sharing.

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 viewing sharing settings but does not explicitly state when to use this tool versus alternatives. It lacks guidance on situations where this tool is appropriate and when other tools should be used.

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 exist, so the description must disclose behavioral traits. It only describes parameters and actions, but does not mention side effects (e.g., modifications to notebooks), execution model (sync/async), or required permissions. This is insufficient for safe 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?

The description is brief and well-structured with a short intro, bulleted actions, and bulleted args. Every sentence provides 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 presence of an output schema and moderate complexity, the description covers the essential usage. It could mention that input_url is optional only for certain pipelines, 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 carries full weight. It explains each parameter, including conditional requirements (e.g., notebook_id required for action=run) and the substitution behavior of input_url. This adds 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 manages and executes multi-step notebook pipelines, and lists two specific actions (run and list). This distinguishes it from sibling tools that deal with notebooks in other ways.

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 use the tool for two actions but does not provide guidance on when to choose this tool over alternatives like 'batch' or other notebook tools. Usage is implied but not explicitly contrasted.

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?

Without annotations, the description carries the behavioral burden. It discloses that tokens are reloaded or re-authentication is attempted and returns a status. However, it lacks details on side effects, failure modes, or required permissions, which is a gap for a mutation-like 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?

The description is four sentences, front-loaded with the core purpose, followed by usage guidance and return info. 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?

For a 0-parameter tool with an output schema (implied by 'Returns status'), the description is complete: it explains when to call, what happens, and what to expect as output. No gaps identified.

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

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

The tool has zero parameters and 100% schema coverage, so the baseline is 4. The description does not need to add parameter meaning, but it effectively explains the tool's action without requiring 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 'Reload auth tokens from disk or run headless re-authentication', specifying the exact action and resource. It distinguishes from sibling tools like save_auth_tokens by implying when to use (after nlm login).

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 provides usage context: 'Call this after running nlm login to pick up new tokens, or to attempt automatic re-authentication if Chrome profile has saved login.' This tells the agent exactly when to use 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 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?

Without annotations, the description discloses key behaviors: search time (~30s fast, ~5min deep), source counts, and asynchronous polling. It does not mention auth requirements or rate limits, but the async workflow 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 and well-structured: purpose first, then usage examples, workflow, and argument list. No superfluous words; 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, workflow, and all parameters. Output schema exists for return values. Could be more complete by mentioning error cases or prerequisites, but overall sufficient for an async search 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 provides clear, actionable explanations for all five parameters (e.g., query, source, mode, notebook_id, title). 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 'Search web or Google Drive to FIND NEW sources' with specific verb and resource. It differentiates from siblings by focusing on source discovery, but could more explicitly contrast with other search tools like 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?

Provides explicit 'Use this for:' examples and a workflow (research_start -> poll -> import). However, it does not specify when NOT to use this tool, such as for querying existing notebooks.

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 full burden. It discloses fallback nature, deprecated parameters, and auto-extraction. However, does not explicitly state whether it overwrites tokens or other side effects.

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 with sections. Slightly verbose but each sentence adds value. Front-loads purpose and critical usage instruction.

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, when to use, and parameter meanings. Missing output schema details but acceptable for a token-saving tool with expected simple output.

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 needed meaning. Each parameter has a brief explanation (e.g., deprecated, auto-extracted, optional). Adds value beyond 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?

Clearly states it saves NotebookLM cookies as a fallback method, with a specific verb and resource. Distinguishes itself from siblings by referencing the preferred CLI method 'nlm login'.

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 use 'nlm login' first and only fall back to this tool if that fails. Provides clear when-to-use and when-not-to-use guidance.

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

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

No annotations are provided, so the description must carry the 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?

No annotations provided, so description carries burden. States permanence and confirmation, but lacks details on side effects like cascading deletions.

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 with front-loaded key information (permanence, confirmation). 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?

Covers purpose, parameters, and critical requirement. Lacks behavioral context like return values, but output schema exists; still could mention confirmation flow.

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

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

Schema has 0% description coverage; description fully explains each parameter (source_id, source_ids, confirm) including distinction between single/bulk and requirement for confirm=True.

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 action 'Delete' and resource 'source(s)' with emphasis on permanence. Distinguishes from sibling tools like source_add or source_describe.

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

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

Includes critical requirement 'confirm=True' and notes irreversibility, but lacks explicit when-to-use context versus 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?

Without annotations, the description carries full burden. It only specifies the return (summary and keywords) but does not disclose whether it is read-only, any side effects, caching behavior, or permissions needed. The behavioral transparency is minimal.

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 the purpose front-loaded in the first sentence. It efficiently describes args and returns without unnecessary 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 simple nature of the tool (one parameter, no nested objects) and the presence of an output schema, the description is nearly complete. It could mention if the summary is always generated fresh or if it uses caching, but overall it is 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?

The schema coverage is 0%, so the description adds value by clarifying that source_id is a 'Source UUID', which is not explicit in the schema. However, it does not provide additional formatting or validation beyond the type.

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 'Get AI-generated source summary with keyword chips', which is a specific verb+resource combination that clearly indicates the tool retrieves a source summary. It distinguishes from siblings like source_delete and source_rename.

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 like source_get_content or other source-related tools. There is no mention of context, prerequisites, or when not to use it.

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

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

No annotations are provided, so description carries full burden. It states 'raw text content' and 'no AI processing', implying a read-only operation. However, it does not disclose authentication needs, rate limits, or error behavior. Adequate but not exhaustive.

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

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

Two sentences plus a parameter list, front-loaded with main purpose. Every sentence adds value; no redundancy or 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?

Although output schema exists, description already details return fields (content, title, source_type, char_count). Missing edge cases or error conditions, but for a simple retrieval tool it is fairly 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 has 0% description coverage, so description must compensate. It describes 'source_id: Source UUID', adding the concept of UUID to the schema type. This is minimal but sufficient for a single parameter; baseline is 3.

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 verb 'Get', the resource 'raw text content of a source', and explicitly mentions no AI processing. It distinguishes from sibling tool '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?

Explicitly recommends this tool over 'notebook_query' for content export due to speed. Does not explicitly exclude other contexts or mention prerequisites, but the contrast provides clear 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 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?

With no annotations, the description must fully disclose behavioral traits. It only states it renames, but offers no information about side effects, permissions required, or constraints (e.g., whether the source can be renamed if it has dependencies). This is minimal disclosure.

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

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

The description is extremely concise with two sentences total. The first sentence states the purpose, and the second lists parameters. No unnecessary words, making it easy to scan.

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

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

The description is minimal and does not explain return values (though output schema exists). It lacks information about constraints, error conditions, or the effect on related resources. For a simple rename, it is marginally adequate but leaves gaps about behavioral details.

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

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

The input schema has 0% description coverage, so the parameter names alone provide no meaning. The description compensates by explicitly listing each parameter with a short explanation (e.g., 'Notebook UUID containing the source'). This adds necessary context 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 'Rename' and the resource 'source in a notebook', which is specific and unequivocal. It distinguishes from sibling tools like source_delete or source_add by naming a distinct operation.

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

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

The description provides no guidance on when to use this tool vs alternatives. It does not mention prerequisites, limitations, or contexts where renames are not allowed. Sibling tool names are available but the description itself lacks usage context.

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

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

No annotations exist, so the description must disclose behavioral traits. It mentions the confirm requirement but lacks details on side effects (overwriting, rate limits, idempotency, duration). More context would improve transparency.

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

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

Three sentences with key points front-loaded. Every sentence earns its place—purpose, prerequisite, and parameter explanation—without 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?

An output schema exists, so return values are covered. The description covers prerequisites and required parameter, but lacks detail on behavior when confirm=False (e.g., immediate failure or prompt). Still adequate for a mutation tool with 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 coverage is 0%, so the description must add meaning. It explains source_ids as 'Source UUIDs to sync' and confirm as 'Must be True after user approval,' providing context beyond the schema's type and default.

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,' clearly identifying the verb 'sync' and resource 'Drive sources.' It also mentions a prerequisite (calling source_list_drive), which helps distinguish it from sibling tools like source_add, source_delete, 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 states 'Requires confirm=True' and advises calling source_list_drive first to identify stale sources, providing clear when and how to use this tool versus 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 full burden. It explains the confirm parameter and mentions user approval, implying necessary interactivity. However, it does not disclose potential side effects (e.g., overwriting artifacts) or rate limits. The behavioral impact remains somewhat opaque.

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, detailed bullet points, and examples. It is appropriately sized for 22 parameters, though some redundancies (e.g., repeating artifact types in the args list) could be trimmed.

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 does not need to explain return values. It thoroughly covers parameter semantics and usage patterns. Missing confirmation on whether creation is asynchronous or what happens on failure is a minor gap.

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

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

With 0% schema description coverage, the description fully compensates by detailing each parameter, including type-specific options and defaults. It groups parameters by artifact type and explains their purpose, exceeding mere schema information.

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 all NotebookLM studio artifacts, listing nine types. It distinguishes itself from siblings like podcast_create (which is audio-only) and studio_revise (modification), making its purpose 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?

The description indicates it is the primary creation tool and provides an example with confirm=True. However, it does not explicitly state when to avoid this tool in favor of alternatives like podcast_create or when not to use it (e.g., for revision), leaving implicit 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?

The description explicitly states the action is irreversible and requires user confirmation (confirm=True). Without annotations, it adequately conveys the destructive nature of the tool.

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

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

The description is extremely concise with three lines, front-loading the essential information: action, irreversibility, and parameter requirements.

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

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

The description does not explain return values, but output schema exists. It does not distinguish between deleting a studio artifact versus the entire notebook, which could be ambiguous given sibling notebook_delete.

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 significant meaning beyond the input schema by explaining that notebook_id is a Notebook UUID, artifact_id is an Artifact UUID from studio_status, and confirm must be set to 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 clearly states the tool deletes a studio artifact, using specific verb and resource. It distinguishes from sibling tools like studio_create and studio_revise by being the delete operation.

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 prerequisite context (artifact_id from studio_status) and the confirm parameter requirement, but does not explicitly tell when to use this tool versus alternatives like notebook_delete or source_delete.

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, so description bears full burden. It clearly states the original artifact is not modified and a new artifact is created. However, it does not mention potential side effects like resource 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?

Description is well-structured with purpose, usage notes, args list, and an example. 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?

Covers the revision process, non-destructive behavior, and polling requirement. Output schema exists but not described; however, the key outcome (new artifact) is stated. Could mention return value but 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 coverage is 0%, but the description explains all parameters: notebook_id, artifact_id, slide_instructions (with format and example), and confirm (must be True). The example further clarifies 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 'Revise individual slides in an existing slide deck. Creates a NEW artifact.' It specifies the action (revise), resource (slides), and distinguishes from creation tools like studio_create.

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 'Only slide decks support revision.' and instructs to poll studio_status for readiness. Also requires confirm=True after user approval, guiding the agent on when and how to invoke.

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 exist, so the description carries full burden. It discloses the rename action and return structure but lacks details on side effects (e.g., whether rename overwrites or is reversible).

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 and Returns sections, front-loading the main purpose. It is slightly verbose but 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?

The description covers all parameter requirements, default behaviors, and return values for each action, providing complete guidance for a tool with moderate 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 input schema has 0% description coverage, but the description fully compensates by detailing each parameter's purpose, required conditions, and defaults, adding significant meaning beyond 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 explicitly states the tool checks studio content generation status and renames artifacts, clearly distinguishing it from sibling tools like studio_create and studio_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?

The description details three actions (status, rename, list_types) with their parameters, providing clear guidance on when to use each. It does not explicitly exclude alternatives but implies the correct context.

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

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

No annotations are provided, so the description carries the full burden. It discloses that add/remove modify tags and list/select are read-only. However, it does not mention permissions, error conditions, or side effects beyond tag changes. This is adequate for a straightforward tag management tool.

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

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

The description is concise and well-structured: an overall purpose sentence, then bulleted actions and their requirements, followed by a clear list of arguments. 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?

The description covers all four actions and their parameter needs. An output schema exists, so return values don't need explanation. For a tool with 5 parameters and moderate complexity, the description is complete and 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%, and the description compensates fully by explaining each parameter's purpose, format (e.g., 'Comma-separated tags'), and when they are required. It also provides examples for tags and query, adding significant 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?

The description clearly states 'Manage notebook tags and find relevant notebooks by tag matching,' specifying verb and resource. It lists four distinct actions (add, remove, list, select) which differentiate it from sibling tools like notebook_create or source_add that handle other 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 explains when each action is appropriate and which parameters are required per action (e.g., add/remove require notebook_id and tags; select requires query). It does not explicitly state when not to use but provides clear context for each operation.

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