NotebookLM MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.15
Disambiguation4/5
Most tools have distinct purposes, but there is some overlap between creation tools (e.g., audio_overview_create, video_overview_create, slide_deck_create) that could cause confusion due to similar naming and parameters. However, the descriptions clarify their specific output formats, preventing major misselection.
Naming Consistency5/5
Tool names follow a consistent snake_case pattern with clear verb_noun structure (e.g., notebook_create, source_delete, research_start). There are no deviations in naming conventions, making the set predictable and easy to parse.
Tool Count3/5
With 32 tools, the count is borderline high for the domain of notebook management and content generation. While the tools cover many features, the number may feel heavy and could overwhelm agents, though it aligns with a comprehensive feature set.
Completeness5/5
The toolset provides complete CRUD/lifecycle coverage for notebooks and sources, along with extensive content generation, research, and authentication workflows. There are no obvious gaps, and the surface supports all core operations for the domain.
Average 3.8/5 across 32 of 32 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'configure' (implying mutation) but doesn't specify permissions required, whether changes are reversible, rate limits, or what the output contains. The description lacks critical behavioral details for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the purpose clearly. The Args section is organized but could be more concise (e.g., combining lines). Overall, it's efficient with minimal waste, though slight improvements in formatting could achieve a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 parameters with 0% schema coverage and an output schema (which reduces need to explain returns), the description is moderately complete. It covers parameters but lacks behavioral context (e.g., mutation effects, error handling) and usage guidelines. For a configuration tool with no annotations, it should provide more context to be fully adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 lists all 4 parameters with brief explanations (e.g., 'Notebook UUID', 'default|learning_guide|custom'), adding meaning beyond the bare schema. However, it doesn't fully detail constraints like 'max 10000 chars' for custom_prompt or explain enum values thoroughly, leaving some gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Configure notebook chat settings.' It specifies the verb ('configure') and resource ('notebook chat settings'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'notebook_create' or 'notebook_configure' (if such existed), which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives. It doesn't mention prerequisites (e.g., needing an existing notebook), exclusions, or comparisons to sibling tools like 'notebook_get' or 'notebook_describe'. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose permissions needed, whether this is a mutation (implied by 'Add'), what happens on success/failure, or any rate limits. The phrase 'as source' hints at context but is vague.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded with the core purpose, followed by parameter details. No wasted sentences, though the 'Args' formatting is slightly verbose. It efficiently conveys essential information in a compact form.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, but an output schema exists, the description is minimally adequate. It covers the purpose and parameters but misses behavioral context and usage guidelines. The output schema reduces need for return value explanation, but gaps remain for a mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description's 'Args' section documents all three parameters with basic semantics (e.g., 'Notebook UUID', 'Text content to add', 'Optional title'). This compensates partially, though it lacks format details or examples. With 0% coverage, baseline would be lower, but the description adds meaningful value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add pasted text as source') and resource (notebook), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'notebook_add_drive' or 'notebook_add_url' beyond implying text content vs. other source types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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_add_drive' or 'notebook_add_url'. The description only states what it does, not when it's appropriate or what distinguishes it from similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Add URL as source') but doesn't clarify whether this is a mutation (likely yes), what permissions are required, how errors are handled, or what the output contains. For a tool that modifies data, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by a structured Args section. It avoids unnecessary fluff, but the Args formatting could be more integrated (e.g., as part of the narrative). Overall, it's efficient but not perfectly seamless.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters with 0% schema coverage, no annotations, but an output schema exists, the description is minimally adequate. It covers the basic what and parameters but lacks behavioral context, usage guidelines, and parameter details. The output schema mitigates some gaps, but for a mutation tool, more is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 lists both parameters (notebook_id, url) and provides minimal semantics ('Notebook UUID', 'URL to add'), which adds value beyond the bare schema. However, it doesn't explain format constraints (e.g., URL validation, UUID format) or provide examples, leaving gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add URL as source') and specifies the resource type ('website or YouTube'), which distinguishes it from sibling tools like notebook_add_text or notebook_add_drive. However, it doesn't explicitly differentiate from all siblings (e.g., research_import might also handle URLs), so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives like notebook_add_text, notebook_add_drive, or research_import. It lacks context about prerequisites (e.g., notebook must exist) or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states this is a list operation, implying read-only behavior, but doesn't disclose important behavioral traits like pagination, sorting, authentication requirements, rate limits, or what happens when max_results is exceeded. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences that each serve a purpose: the first states the core functionality, the second explains the parameter. It's front-loaded with the main purpose. However, the 'Args:' formatting is slightly redundant with the schema and could be more integrated, preventing a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single optional parameter) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and siblings offering similar functionality, it should provide more context about when to use this versus notebook_query or about behavioral aspects like ordering. It meets basic requirements but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 documents the single parameter 'max_results' with its default value, which adds meaning beyond the bare schema. However, it doesn't explain parameter constraints (e.g., minimum/maximum values) or how the parameter affects the listing behavior. With one parameter documented but not fully, this meets the baseline for adequate coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 'notebooks', making the purpose immediately understandable. It distinguishes from siblings like notebook_create, notebook_delete, and notebook_describe by indicating this is a listing operation. However, it doesn't specify whether this lists all notebooks globally or within a specific scope, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives. With siblings like notebook_query (which likely offers filtering capabilities) and notebook_get (which retrieves a specific notebook), there's no indication of when this unfiltered list is preferred over those more targeted tools. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the confirmation requirement ('Requires confirm=True after user approval'), which adds some behavioral context, but it lacks details on permissions, side effects (e.g., if it modifies existing data), rate limits, or output format. For a tool that likely creates persistent content, this is insufficient disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the main purpose, followed by a structured Args section. It's relatively concise with no wasted sentences, though the Args formatting could be more integrated into the flow. Overall, it's efficient but not perfectly polished.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, 4 parameters, and an output schema present, the description is moderately complete. It covers the basic purpose and parameters but lacks details on behavior, error handling, or output, relying on the output schema for return values. For a creation tool, it should provide more context on what 'saving' entails.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 lists parameters with brief explanations (e.g., 'Notebook UUID', 'Source IDs (default: all)'), adding basic semantics beyond the schema. However, it doesn't fully clarify usage, such as what 'source_ids' refers to or the implications of 'confirm', leaving gaps for a tool with 4 parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Generate and save mind map') and resource ('mind map'), making the purpose understandable. It doesn't explicitly differentiate from sibling tools like 'infographic_create' or 'slide_deck_create', which might create similar visual outputs, so it misses the highest score for sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context with 'Requires confirm=True after user approval,' suggesting a confirmation step, but it doesn't explicitly state when to use this tool versus alternatives like 'infographic_create' or other content-creation siblings. No clear exclusions or prerequisites are provided beyond the confirmation requirement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the confirmation requirement, which is valuable context, but doesn't describe what 'Generate data table' actually does (e.g., creates a structured table in a notebook, potentially with data processing), what permissions are needed, whether it's reversible, or what happens on success/failure. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with a brief purpose statement followed by parameter explanations. However, it's not optimally front-loaded—the critical 'Requires confirm=True after user approval' is in the first sentence but buried after the purpose, and the Args section uses inconsistent formatting (e.g., mixing quotes and no quotes). Some sentences could be more efficient, like combining the confirmation requirement with the parameter explanation for 'confirm'.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters with 0% schema coverage and no annotations, but with an output schema present, the description provides basic coverage of parameters and a key behavioral constraint (confirmation). However, for a mutation tool that creates data tables, it lacks details on what the tool actually generates, error conditions, or how it interacts with the notebook system, making it minimally adequate but with clear gaps in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 provides basic semantics for all 5 parameters in the Args section, explaining what each parameter represents (e.g., 'Notebook UUID', 'Description of the data table to create'). However, it doesn't add deeper meaning like format details for 'notebook_id' or what 'source_ids' actually refer to, leaving some ambiguity despite covering all parameters nominally.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Generate' and resource 'data table', making the purpose understandable. However, it doesn't differentiate from sibling tools like 'notebook_add_text' or 'report_create' that might also generate content, leaving some ambiguity about when this specific table creation tool is appropriate versus alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance through the 'Requires confirm=True after user approval' statement, which suggests this tool should be used only after explicit user confirmation. However, it doesn't explicitly state when to use this tool versus alternatives like 'notebook_add_text' for adding content or 'report_create' for structured output, nor does it mention prerequisites beyond the confirmation requirement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool checks status and gets URLs, implying a read-only operation, but doesn't specify whether it requires authentication, has rate limits, returns paginated results, or details error conditions. For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with the core purpose stated first ('Check studio content generation status and get URLs.') followed by a brief parameter note. It avoids unnecessary elaboration, but the parameter section could be more integrated into the main text for better flow.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose and parameter meaning adequately, though it lacks behavioral details and usage guidelines, which are minor gaps in this context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal parameter semantics: it notes 'notebook_id: Notebook UUID', which clarifies the parameter's purpose beyond the schema's basic type (string). However, with 0% schema description coverage and only 1 parameter, this provides some value but doesn't fully compensate for the lack of schema details (e.g., format constraints). The baseline is appropriate given the low parameter count.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Check studio content generation status and get URLs.' It specifies the verb ('Check') and resource ('studio content generation status'), and distinguishes it from siblings like 'research_status' by focusing on 'studio' content. However, it doesn't explicitly differentiate from 'studio_delete' or other studio-related tools, keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives. It mentions 'notebook_id' as a required argument, implying usage after notebook creation, but offers no explicit context, exclusions, or comparisons to sibling tools like 'research_status' or 'studio_delete'. This lack of usage guidance limits its effectiveness for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Create a new notebook', implying a write operation, but does not disclose any behavioral traits like permissions needed, whether creation is idempotent, rate limits, or what happens on failure. This is a significant gap for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the main purpose stated concisely in the first sentence and parameter details in a structured 'Args:' section. Every sentence earns its place without waste, making it efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a simple creation tool with 1 parameter), the description is minimally complete but lacks depth. It has an output schema, so return values need not be explained, but with no annotations and incomplete behavioral context, it leaves gaps in understanding the tool's full behavior and usage scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning beyond the input schema by explaining that 'title' is an 'Optional title for the notebook', which clarifies its purpose and optionality. With 0% schema description coverage and only 1 parameter, this compensates well, though it could provide more detail like format constraints or default behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Create' and the resource 'a new notebook', which is specific and unambiguous. However, it does not differentiate from sibling tools like 'notebook_add_drive' or 'notebook_add_text', which also involve notebooks but for different purposes, so it lacks explicit sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives. It does not mention any context, prerequisites, or exclusions, such as when to choose this over 'notebook_list' or 'notebook_get', leaving the agent without usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'Get's data (implying a read operation) and returns specific outputs, but lacks details on permissions, rate limits, or whether it's idempotent. For a tool with zero annotation coverage, this is insufficient for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by clear sections for args and returns, making it efficient and well-structured. However, the 'Args' and 'Returns' labels are slightly redundant since the schema and output schema cover this, but they don't significantly detract from conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter), the presence of an output schema (which handles return values), and no annotations, the description is reasonably complete. It covers the purpose, parameter semantics, and return structure, though it could benefit from more behavioral context to fully compensate for the lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context beyond the schema: it specifies that 'notebook_id' is a 'Notebook UUID', clarifying the format and purpose of the single parameter. With 0% schema description coverage and only one parameter, this adequately compensates, though it could note if the UUID must be valid or from a specific source.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 'AI-generated notebook summary with suggested topics', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'notebook_get' or 'notebook_query', which likely retrieve raw notebook data rather than AI-generated summaries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives like 'notebook_get' or 'notebook_query'. It mentions what it returns but doesn't specify use cases, prerequisites, or exclusions, leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Get notebook details with sources', which implies a read-only operation, but doesn't disclose behavioral traits such as permissions needed, rate limits, or what 'sources' entails. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence, followed by a brief parameter note. Every sentence earns its place with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 (which handles return values), 1 parameter, and no annotations, the description is reasonably complete for a simple retrieval tool. It covers the purpose and parameter meaning, though more behavioral context would improve it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds minimal semantics by specifying 'Notebook UUID' for the notebook_id parameter. However, with only 1 parameter and no schema descriptions, this provides basic clarification but doesn't fully compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'notebook details with sources', making the purpose understandable. It distinguishes from siblings like notebook_list (which lists notebooks) and notebook_describe (which might describe without sources), though the distinction could be more explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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_query. The description implies retrieval of details with sources, but lacks explicit context or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Rename' implies a mutation operation, but the description doesn't state whether this requires specific permissions, if the change is reversible, what happens to the old title, or any rate limits. It lacks critical context for a write operation with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded: the first sentence states the core purpose, followed by a clear Args section. Every sentence earns its place with no wasted words, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 (which handles return values), 2 parameters with 0% schema coverage (compensated by description), and no annotations, the description is minimally adequate. It covers the basic operation and parameters but lacks behavioral details for a mutation tool, leaving gaps in permissions, effects, and error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explicitly lists both parameters (notebook_id and new_title) with brief explanations, adding meaningful semantics beyond the schema. Since schema description coverage is 0% (no descriptions in schema properties), this compensates well by clarifying what each parameter represents, though it doesn't provide format details like UUID structure or title constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'rename' and the resource 'notebook', making the purpose immediately understandable. It distinguishes from siblings like notebook_create, notebook_delete, and notebook_describe by focusing specifically on renaming. However, it doesn't explicitly differentiate from all siblings (e.g., notebook_add_text could be seen as modifying content).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives. It doesn't mention prerequisites (e.g., needing an existing notebook), exclusions, or comparisons to similar tools like notebook_describe (which might retrieve metadata) or notebook_create (which creates new notebooks). The agent must infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool generates an AI summary and returns specific output formats, but lacks critical details: whether this is a read-only operation, if it requires authentication, potential rate limits, or error conditions. For a tool with no annotations, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured: a clear purpose statement followed by brief but informative sections for Args and Returns. Every sentence earns its place, with no redundant information, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (AI-generated summary), no annotations, and the presence of an output schema (implied by 'Returns'), the description is reasonably complete. It covers the purpose, parameter semantics, and output format. However, it lacks behavioral context like authentication needs or error handling, which slightly reduces completeness for a tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter: it specifies that 'source_id' is a 'Source UUID', clarifying the expected format beyond the schema's generic string type. With 0% schema description coverage and only one parameter, this compensation is effective, though it doesn't detail UUID validation or examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 AI-generated source summary with keyword chips.' It specifies the action ('Get'), resource ('source'), and output characteristics ('summary with keyword chips'). However, it doesn't explicitly differentiate from sibling tools like 'source_get_content' or 'notebook_describe', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 versus alternatives. It doesn't mention sibling tools like 'source_get_content' (which might retrieve raw content) or 'notebook_describe' (which might describe notebooks), leaving the agent without context for tool selection. The only implied usage is for summarizing sources, but no exclusions or comparisons are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the critical behavioral trait that user approval is required (confirm parameter), which is valuable. However, it doesn't mention other important behaviors like whether this is a destructive operation, what permissions are needed, rate limits, or what the output looks like. The description adds some context but leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but not optimally structured. The first sentence is front-loaded with the core purpose and key requirement. However, the parameter documentation uses a separate 'Args:' section which breaks flow. Some sentences could be more concise, like 'Must be True after user approval' could be simplified to 'Set to True after user approval.'
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, generation operation) and the presence of an output schema, the description provides good coverage. It explains all parameters meaningfully and includes the critical user approval requirement. The output schema existence means the description doesn't need to explain return values. However, for a generation tool with no annotations, it could benefit from more behavioral context about what 'generate' entails.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 provides meaningful semantic information for all 7 parameters: notebook_id context (Notebook UUID), source_ids meaning (Source IDs with default behavior), format options (detailed_deck|presenter_slides), length options (short|default), language specification (BCP-47 code with examples), focus_prompt purpose (Optional focus text), and confirm requirement (Must be True after user approval). This significantly enhances understanding beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 slide deck' specifies both the verb (generate) and resource (slide deck). It distinguishes from siblings like 'infographic_create' or 'report_create' by focusing on slide decks specifically. However, it doesn't explicitly differentiate from 'presentation' tools that might exist elsewhere.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context with 'Requires confirm=True after user approval' which indicates when to use this tool (after user approval). It doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools, but the approval requirement provides meaningful guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the confirm requirement for user approval, which is a key behavioral trait. However, it lacks details on other behaviors like rate limits, error handling, or what the audio overview entails (e.g., duration, format specifics). This is adequate but has gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the main purpose, followed by a structured Args section. Every sentence adds value, but the Args formatting could be more integrated into the flow rather than a separate block, slightly reducing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no annotations, but has output schema), the description is fairly complete. It covers purpose, usage guidelines, and parameter semantics. With an output schema present, it doesn't need to explain return values, but it could benefit from more behavioral context (e.g., what the audio output is like).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 meaningful semantics for all parameters: notebook_id (Notebook UUID), source_ids (Source IDs with default), format (deep_dive|brief|critique|debate), length (short|default|long), language (BCP-47 code), focus_prompt (Optional focus text), and confirm (Must be True after user approval). This provides clear context beyond the bare schema, though it doesn't fully explain enum values or defaults, keeping it from a 5.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Generate audio overview' with specific parameters like format, length, and language, making it clear this creates an audio summary. However, it doesn't explicitly differentiate from sibling tools like 'video_overview_create' or other content creation tools in the list, which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context with 'Requires confirm=True after user approval', indicating when to use this tool (after approval). It doesn't specify alternatives or exclusions (e.g., vs. other overview tools), so it's not a full 5, but the approval requirement is explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Add') which implies a write operation, but does not describe permissions needed, whether the operation is idempotent, error conditions, or what happens on success (e.g., if the document becomes linked or copied). This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by a structured 'Args:' section that efficiently lists parameters with brief explanations. Every sentence adds value without redundancy, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 (which handles return values), no annotations, and 4 parameters with 0% schema coverage, the description does well by explaining all parameters and the tool's purpose. However, it lacks details on behavioral aspects like error handling or integration effects, which are important for a write operation with no annotation support.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 meaningful context for all parameters: 'notebook_id' as Notebook UUID, 'document_id' as Drive document ID from URL, 'title' as display title, and 'doc_type' with enum values (doc|slides|sheets|pdf). This clarifies the purpose and format of each parameter beyond the basic schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Add Google Drive document as source'), identifies the resource (Google Drive document), and distinguishes it from siblings like 'notebook_add_text' and 'notebook_add_url' by specifying the document source type. It provides a verb+resource combination that is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by specifying the tool adds a Google Drive document as a source, suggesting it's for integrating external documents into notebooks. However, it lacks explicit guidance on when to use this tool versus alternatives like 'notebook_add_url' or 'source_sync_drive', and does not mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the user approval requirement (important behavioral constraint) but doesn't describe what the tool actually produces (output format), potential side effects, or performance characteristics. The description adds some behavioral context but leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a brief purpose statement followed by parameter explanations. Every sentence adds value, though the confirm requirement is stated twice ('Requires confirm=True' and 'Must be True'), creating minor redundancy. The information is well-organized and appropriately sized for a 7-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (7 parameters, no annotations, but has output schema), the description is moderately complete. It covers parameter semantics well and includes the critical user approval requirement. However, it doesn't explain what an 'infographic' output entails (format, content, size) or how the tool behaves operationally. The existence of an output schema reduces but doesn't eliminate the need for some behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 provides semantic meaning for all 7 parameters: notebook_id (Notebook UUID), source_ids (Source IDs with default behavior), orientation (landscape|portrait|square options), detail_level (concise|standard|detailed options), language (BCP-47 codes), focus_prompt (Optional focus text), and confirm (Must be True after user approval). This adds substantial value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Generate') and resource ('infographic'), making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like 'slide_deck_create' or 'report_create', but the specific output type (infographic) provides reasonable distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'Requires confirm=True after user approval' and 'Must be True after user approval' for the confirm parameter. This clearly indicates when the tool should be used (after obtaining user consent) and establishes a prerequisite condition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It implies this is a read operation (listing) and hints at behavioral context by mentioning 'freshness status' and its role in identifying stale sources. However, it doesn't disclose permissions needed, rate limits, pagination, or what 'freshness status' entails (e.g., timestamps, sync states). The description adds some value but lacks comprehensive behavioral details for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the purpose, the second provides usage guidelines, and the third documents the parameter. Every sentence earns its place with no wasted words, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 1 parameter with 0% schema coverage, no annotations, but an output schema exists, the description is fairly complete. It covers purpose, usage, and parameter semantics. The output schema likely handles return values, so the description doesn't need to explain them. However, for a tool with no annotations, it could benefit from more behavioral context (e.g., permissions, data format).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by explaining the single parameter: 'notebook_id: Notebook UUID'. This adds meaning beyond the schema's basic type/requirement, clarifying it's a UUID for a notebook. With 0% coverage and 1 parameter, the description fully documents the parameter, earning a high score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and resource 'sources', specifying they include 'types and Drive freshness status'. It distinguishes from siblings like source_describe or source_get_content by focusing on listing with freshness status rather than detailed information or content retrieval. However, it doesn't explicitly differentiate from notebook_list or other list tools beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Use before source_sync_drive to identify stale sources.' This gives a clear when-to-use context (as a precursor to syncing) and implies an alternative (source_sync_drive). However, it doesn't specify when NOT to use it or compare to other listing tools like notebook_list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 a key behavioral trait: the need for user approval via 'confirm=True,' which is crucial for a generative tool. However, it lacks details on other behaviors like rate limits, error handling, or what the output entails (though an output schema exists). The description adds value but is incomplete for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded: the first sentence states the purpose and key requirement, followed by a bullet-style 'Args' section. Every sentence earns its place by providing essential information without redundancy. It's appropriately sized for a tool with 7 parameters and no annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, generative function) and lack of annotations, the description does a solid job. It covers purpose, usage guidelines, and parameter semantics. With an output schema present, it doesn't need to explain return values. However, it could improve by mentioning sibling tools or more behavioral details, but it's largely complete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 meaningful semantics for all 7 parameters, explaining their purposes (e.g., 'notebook_id: Notebook UUID,' 'format: explainer|brief'). This goes beyond the bare schema, providing context like enum values for 'visual_style' and language codes. The description effectively clarifies parameter roles, though it could note defaults or optionality more explicitly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 video overview.' It specifies the resource (video overview) and verb (generate), making it distinct from siblings like 'audio_overview_create' or 'slide_deck_create.' However, it doesn't explicitly differentiate from all siblings (e.g., 'report_create' might also generate content), so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage: 'Requires confirm=True after user approval.' This indicates when to use it (after approval) and implies a prerequisite (user consent). It doesn't explicitly state when not to use it or name alternatives among siblings, but the guidance is practical and helpful for safe invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the confirm requirement, which is a key behavioral constraint, but doesn't describe what 'Generate flashcards' entails operationally (e.g., how many flashcards, what content they contain, whether this is a one-time or batch process, or any rate limits). It adds some value but leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose and key requirement. The Args section is well-structured but includes some redundancy (e.g., repeating 'Requires confirm=True' in both the main description and parameter details). Every sentence earns its place, though minor trimming could improve efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (4 parameters, 1 required), no annotations, and the presence of an output schema (which handles return values), the description is fairly complete. It covers the purpose, usage condition, and parameter meanings. However, it lacks details on what the generation process involves or any error conditions, leaving room for improvement in behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 provides meaningful semantics for all 4 parameters: notebook_id as 'Notebook UUID', source_ids as 'Source IDs (default: all)', difficulty with values 'easy|medium|hard', and confirm with the critical 'Must be True after user approval'. This adds substantial context beyond the bare schema, though it could elaborate on source_ids (e.g., what sources are).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Generate') and resource ('flashcards'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'quiz_create' or 'mind_map_create' which might also involve learning content creation, missing the opportunity to clarify its unique role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance by stating 'Requires confirm=True after user approval' and reiterating this in the confirm parameter description. This clearly indicates when to use the tool (after user approval) and includes a prerequisite condition, offering strong contextual direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 the confirm requirement, which is a behavioral trait, but lacks details on permissions, rate limits, what happens on failure, or the quiz generation process. It's adequate but has gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with a front-loaded main sentence and a structured Args section. Every sentence adds value, though the Args formatting could be slightly more integrated for better flow.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters with 0% schema coverage and no annotations, the description does well by explaining all parameters and including a usage guideline. An output schema exists, so return values needn't be described. It's mostly complete but could benefit from more behavioral context for a mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning for all 5 parameters by explaining their purposes (e.g., 'Notebook UUID', 'Source IDs (default: all)'), which goes beyond the bare schema. However, it doesn't detail formats like UUID structure or difficulty enum values, keeping it from a perfect score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Generate' and resource 'quiz', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'flashcards_create' or 'report_create' which might also generate educational content, so it misses full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance with 'Requires confirm=True after user approval', indicating when to use this tool (after user approval) and a prerequisite condition. This is clear and actionable for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates this is a write operation ('Import') and specifies a prerequisite condition, but doesn't describe what happens during import (e.g., whether it overwrites existing content, how sources are formatted in the notebook, or what permissions are required). The description adds some behavioral context but leaves significant gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured and concise. The first sentence states the core purpose, the second provides crucial usage guidance, and the Args section efficiently documents parameters. Every sentence earns its place with no wasted words, making it easy for an agent to parse and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a mutation tool with no annotations but with an output schema (which handles return values), the description provides good contextual coverage. It explains the purpose, usage prerequisites, and parameter meanings. The main gap is insufficient behavioral transparency about what the import operation actually does, but the presence of an output schema means the description doesn't need to explain return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates well by explaining all three parameters in the Args section. It clarifies that notebook_id is a 'Notebook UUID', task_id is a 'Research task ID', and source_indices are 'Source indices to import' with a default of 'all'. This adds meaningful semantic context beyond the bare schema types, though it doesn't explain what format source indices should be in or provide examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Import discovered sources') and target ('into notebook'), making the purpose understandable. It distinguishes this tool from siblings like research_start or research_status by focusing on the import phase. However, it doesn't explicitly differentiate from other notebook-related tools like notebook_add_text or notebook_add_url, which could also add content to notebooks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'Call after research_status shows status="completed".' This creates a clear prerequisite condition and establishes a workflow relationship with the research_status sibling tool, which is exactly what usage guidelines should accomplish.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 this is a sync operation (implying mutation) and requires user confirmation, which is useful behavioral context. However, it doesn't mention potential side effects (e.g., data overwrites), performance impacts, or error handling, leaving gaps for a tool that modifies data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by concise usage guidelines and parameter explanations in a structured format. Every sentence adds value without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, but an output schema exists, the description does well by covering purpose, usage, and parameters. It lacks details on behavioral risks (e.g., data loss) and doesn't explain return values, but the output schema mitigates the latter. For a mutation tool, more safety disclosures would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 explains both parameters: 'source_ids' as 'Source UUIDs to sync' and 'confirm' as requiring user approval and being 'Must be True.' This adds meaningful context beyond the bare schema, though it could detail format constraints for UUIDs or confirm's default behavior more explicitly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Sync Drive sources with latest content') and resource ('Drive sources'), making the purpose understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'source_list_drive' or 'source_get_content' beyond mentioning a prerequisite relationship.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'Call source_list_drive first to identify stale sources.' It also specifies a prerequisite condition: 'Requires confirm=True' and 'Must be True after user approval,' clearly indicating the context and approval needed before invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 this is a fallback method and mentions deprecated parameters (csrf_token, session_id) that are auto-extracted, adding useful context. However, it doesn't describe authentication requirements, error handling, or what 'save' entails (e.g., persistence, security implications), leaving behavioral gaps for a tool handling sensitive cookies.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose and critical usage warnings. Every sentence adds value: the first states the purpose and fallback nature, the next two provide usage guidelines, and the parameter explanations are necessary for clarity. Minor redundancy in 'Deprecated' notes could be streamlined, but overall it's efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (authentication tool with 5 parameters, 0% schema coverage, no annotations, but with an output schema), the description is largely complete. It covers purpose, usage context, and parameter roles effectively. The output schema likely handles return values, so the description doesn't need to explain those. It could improve by addressing security or error details, but it's sufficient for informed tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 significant semantic value: it explains that 'cookies' is the 'Cookie header from Chrome DevTools (only needed if CLI fails)', clarifies that csrf_token and session_id are 'Deprecated - auto-extracted', and notes that request_body and request_url are 'Optional' with specific extraction purposes. This goes well beyond the bare schema, though it doesn't fully detail all parameter formats or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Save NotebookLM cookies (FALLBACK method - try notebooklm-mcp-auth first!)'. It specifies the exact action (save cookies) and resource (NotebookLM authentication tokens), distinguishing it from sibling tools like refresh_auth by being a fallback method for authentication setup rather than a refresh operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines: 'First, run `notebooklm-mcp-auth` via Bash/terminal (automated, preferred)' and 'Only use this tool if the automated CLI fails'. It clearly states when to use this tool (as a fallback) versus the preferred alternative (the CLI tool), including specific conditions for invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the core function (querying existing sources) and mentions timeout behavior with environment variable fallback, but doesn't cover other important aspects like authentication needs, rate limits, error handling, or what the AI response format looks like. It adds some context but leaves gaps for a tool with 5 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement, usage guidelines, and parameter explanations in a bullet-like format. Every sentence earns its place, with no wasted words. The information is front-loaded with the most important guidance first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, no annotations, but with output schema), the description provides good coverage of purpose, usage guidelines, and parameter semantics. The presence of an output schema means the description doesn't need to explain return values. However, it could provide more behavioral context about the AI interaction aspect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate for the lack of parameter documentation in the schema. It provides clear explanations for all 5 parameters: notebook_id (Notebook UUID), query (Question to ask), source_ids (Source IDs to query with default behavior), conversation_id (For follow-up questions), and timeout (Request timeout with default logic). This adds substantial meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 specifies the verb ('Ask AI about'), resource ('EXISTING sources'), and scope ('already in notebook'), and explicitly distinguishes it from sibling 'research_start' for finding new sources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines: 'NOT for finding new sources' and 'Use research_start instead for: deep research, web search, find new sources, Drive search.' This clearly defines when to use this tool versus alternatives, including specific exclusions and named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively reveals key behavioral traits: the tool requires user approval (via 'confirm=True'), implies a generation process that might be resource-intensive or irreversible, and hints at a safety mechanism. However, it doesn't disclose rate limits, authentication needs, error conditions, or what happens to existing reports, leaving some gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the purpose and key requirement, followed by a structured Args section. Every sentence earns its place by providing essential parameter details. However, the Args formatting is slightly verbose, and the purpose statement could be more specific (e.g., 'Generate a report from notebook sources').
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, mutation operation, no annotations) and the presence of an output schema (which handles return values), the description is largely complete. It covers purpose, usage guidelines, and parameter semantics thoroughly. The main gap is the lack of behavioral details like side effects or error handling, but the output schema mitigates this for return values. For a tool with this parameter count and no annotations, it does well but isn't exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate fully. It adds significant meaning beyond the bare schema: it explains that 'notebook_id' is a UUID, 'source_ids' defaults to all sources, 'report_format' has specific options including 'Create Your Own', 'custom_prompt' is required for that format, 'language' uses BCP-47 codes, and 'confirm' must be True after user approval. This covers all 6 parameters with clear semantics and constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 report.' It specifies the resource (report) and implies the action (generation). While it doesn't explicitly differentiate from siblings like 'slide_deck_create' or 'infographic_create,' the term 'report' suggests a distinct output format. However, it lacks specificity about what kind of report (e.g., content summary, analysis) or from what data beyond the notebook context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines: 'Requires confirm=True after user approval.' This clearly indicates when to use the tool (after user approval) and includes a prerequisite condition. It also implies a workflow step (user approval before invocation), though it doesn't name alternatives or specify when-not-to-use scenarios beyond the confirmation requirement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by stating the tool returns 'original indexed text' and is 'much faster' than alternatives, but doesn't mention potential limitations like file size constraints, rate limits, or authentication requirements that would be helpful for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured and front-loaded: first sentence states purpose, second explains performance advantage, third lists supported sources, then clearly separated Args and Returns sections. Every sentence earns its place with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read operation with an output schema (implied by the Returns section), the description provides excellent completeness. It covers purpose, usage guidance, performance characteristics, parameter semantics, and return values - everything needed for effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explicitly documents the single parameter 'source_id' as a 'Source UUID', adding crucial semantic meaning beyond the schema's basic string type. With 0% schema description coverage and only one parameter, this provides excellent compensation and clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get raw text content'), target resource ('of a source'), and scope ('no AI processing'). It explicitly distinguishes from sibling 'notebook_query' by stating it's 'much faster' for content export, providing clear differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('for content export') and when to use an alternative ('much faster than notebook_query'). It also implies usage context by listing supported source types (PDFs, web pages, etc.).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates critical traits: the action is 'IRREVERSIBLE' (destructive), requires user confirmation via 'confirm=True,' and targets a specific resource ('Notebook UUID'). However, it lacks details on permissions, error handling, or rate limits, which would elevate it to a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core action ('Delete notebook permanently. IRREVERSIBLE. Requires confirm=True.') and uses a structured Args section for parameters. Every sentence adds value without redundancy, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (destructive operation with 2 parameters), no annotations, and an output schema present (which reduces need to explain returns), the description is mostly complete. It covers purpose, usage, and parameters well but omits details like authentication needs or error cases, which could be beneficial for full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate fully. It does so by explaining both parameters: 'notebook_id' as 'Notebook UUID' and 'confirm' as 'Must be True after user approval,' adding essential meaning beyond the bare schema. This clarifies the purpose and constraints of each parameter effectively.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete'), target resource ('notebook'), and scope ('permanently'), distinguishing it from sibling tools like notebook_rename, notebook_describe, or notebook_list. It uses specific language that leaves no ambiguity about the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Requires confirm=True' and 'Must be True after user approval,' providing clear conditions for when to use this tool. It implies this is for irreversible deletion, distinguishing it from less destructive alternatives like notebook_rename or notebook_describe among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool does (reloads tokens, attempts re-authentication), the trigger conditions (after running auth command or saved login), and the outcome (returns status). However, it lacks details on error handling or specific authentication mechanisms, which could be useful for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by specific usage scenarios and outcome information. Every sentence adds essential context without waste, making it efficient and well-structured for an AI agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (authentication management with 0 parameters), the description is complete. It explains the purpose, usage guidelines, and behavioral aspects, and with an output schema present, it doesn't need to detail return values. The context is fully covered for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on usage context rather than parameters, earning a high baseline score. It adds value by explaining the tool's purpose and when to use it without redundant parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('reload auth tokens', 'run headless re-authentication') and distinguishes it from sibling tools by focusing on authentication management rather than content creation or notebook operations. It explicitly mentions the relationship with 'notebooklm-mcp-auth' for context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'Call this after running notebooklm-mcp-auth to pick up new tokens' and 'to attempt automatic re-authentication if Chrome profile has saved login.' It also distinguishes it from alternatives by not overlapping with sibling tools like 'save_auth_tokens' or other authentication-related functions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: the action is destructive ('Delete permanently'), irreversible ('IRREVERSIBLE'), and has a safety mechanism ('Requires confirm=True'). This covers critical behavioral aspects beyond what the input schema provides.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core action and warnings, followed by a concise Args section that explains parameters without redundancy. Every sentence adds value, such as emphasizing irreversibility and confirmation requirements, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (destructive operation) and no annotations, the description is mostly complete, covering purpose, behavior, and parameters. However, it does not mention the output schema's content (e.g., success/failure response), which could be helpful. Siblings like source_describe or source_list_drive provide context, but the description stands well on its own.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
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 meaningful semantics for both parameters: 'source_id' is explained as 'Source UUID to delete,' and 'confirm' is clarified with 'Must be True after user approval,' which provides context beyond the schema's basic types. This fully addresses the parameters' purposes and constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete'), the resource ('source'), and the permanence ('permanently'), which distinguishes it from siblings like notebook_delete or studio_delete that delete different resources. The verb+resource combination is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage by specifying 'Requires confirm=True' and 'after user approval,' which indicates when to use it (after confirmation). However, it does not explicitly state when not to use it or name alternatives, such as whether there are soft-delete options or other deletion tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: it's a search operation that initiates research, specifies time and result estimates for modes (fast: ~30s, ~10 sources; deep: ~5min, ~40 sources), notes that deep mode is web-only, and explains notebook creation behavior ('creates new if not provided'). However, it doesn't mention error conditions, rate limits, or authentication needs, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded, starting with the core purpose, followed by usage guidelines, workflow context, and parameter details. Every sentence adds value without redundancy, and it efficiently covers essential information in a compact format, making it easy for an AI agent to parse and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (initiates research with multiple parameters), no annotations, and an output schema (which handles return values), the description is complete enough. It covers purpose, usage, workflow, and all parameter semantics, providing a comprehensive understanding without needing to explain output details, which are handled by the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains all 5 parameters: 'query' with an example ('quantum computing advances'), 'source' with allowed values (web|drive), 'mode' with details on fast vs deep, 'notebook_id' behavior ('Existing notebook (creates new if not provided)'), and 'title' purpose ('Title for new notebook'). This fully compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('search web or Google Drive to FIND NEW sources') and distinguishes it from siblings by explicitly naming the research workflow (research_start → poll research_status → research_import). It provides concrete examples of use cases ('deep research on X', 'find sources about Y'), making the purpose unambiguous and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Use this for: "deep research on X", "find sources about Y", "search web for Z", "search Drive"') and provides a workflow context ('Workflow: research_start -> poll research_status -> research_import'), which helps differentiate it from sibling tools like notebook_query or source_list_drive. It also clarifies mode restrictions ('deep (~5min, ~40 sources, web only)'), offering clear usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does an excellent job disclosing key behavioral traits: it blocks execution, has timeout behavior, provides polling intervals, and explains the compact parameter's effect on token usage and output truncation. The only minor gap is lack of explicit rate limit or authentication requirement disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured and concise: a clear purpose statement followed by well-organized parameter explanations. Every sentence adds value, with no redundant information. The use of bullet-like formatting in the Args section makes it easily scannable while maintaining completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's polling complexity, 5 parameters with 0% schema coverage, no annotations, but with an output schema, the description is remarkably complete. It covers all parameters' meanings, explains the blocking/timeout behavior, provides usage guidance, and mentions the output schema handles return values, leaving no significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
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 explaining all 5 parameters' semantics beyond their types: notebook_id is a UUID, poll_interval is seconds between polls with default, max_wait is maximum seconds with special 0 value meaning single poll, compact controls truncation to save tokens, and task_id is optional for specific task polling.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Poll research progress') and resource ('research'), distinguishing it from siblings like research_start (initiates research) or studio_status (checks studio status). It explicitly mentions blocking behavior and timeout conditions, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: to monitor research completion after starting it, with clear alternatives implied (e.g., use compact=False for full details). It also specifies when not to use it (if you only want a single poll without waiting, set max_wait=0), making usage context very clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the irreversible nature of the operation ('IRREVERSIBLE') and the confirmation requirement, which are critical behavioral traits for a destructive operation that aren't captured in the input schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely efficient with zero wasted words. The first sentence states purpose and critical warnings, followed by a clean parameter explanation section. Every sentence earns its place by providing essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive tool with no annotations, the description does an excellent job covering purpose, warnings, and parameters. The existence of an output schema means return values don't need explanation. One minor gap is not mentioning what 'studio artifact' specifically refers to in this context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
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 explaining all three parameters: notebook_id is described as 'Notebook UUID', artifact_id as 'Artifact UUID (from studio_status)', and confirm as 'Must be True after user approval'. This provides essential semantic context beyond the bare schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete') and resource ('studio artifact'), distinguishing it from siblings like notebook_delete or source_delete by specifying the exact type of artifact being deleted. It provides precise scope information that differentiates it from other deletion tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Delete studio artifact') and includes critical prerequisites ('Requires confirm=True after user approval'), providing clear guidance on the confirmation requirement that must be met before invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![notebooklm-mcp MCP server](https://glama.ai/mcp/servers/Morfeu333/notebooklm-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Morfeu333/notebooklm-mcp)

Score Badge

Copy to your README.md:

[![notebooklm-mcp MCP server](https://glama.ai/mcp/servers/Morfeu333/notebooklm-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Morfeu333/notebooklm-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Morfeu333/notebooklm-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server