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 correctly indicates this is a write operation ('Creates'), but does not mention permissions required, rate limits, whether the operation is idempotent, or what happens on failure. It adds some context about what can be set (properties like title, status, etc.), but lacks comprehensive behavioral details.

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

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

The description is appropriately sized with three sentences that are front-loaded and efficient. The first sentence states the core purpose, the second provides usage context, and the third adds parameter context—each sentence earns its place without redundancy or unnecessary elaboration.

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

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

Given the tool's complexity (write operation with nested objects), no annotations, and no output schema, the description is moderately complete but has gaps. It covers the basic purpose and parameter context, but lacks details on permissions, error handling, return values, or behavioral constraints that would be needed for full contextual understanding.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (databaseId and properties). The description adds marginal value by mentioning property examples (title, status, date, assignee) and linking to update_page format, but does not provide significant additional semantics beyond what the schema already specifies.

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

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

The description clearly states the specific action ('Creates a new page'), resource ('in a Notion database'), and scope ('add new entries such as tasks, projects, notes, etc.'). It distinguishes from siblings like delete_page (deletion), get_page (retrieval), and update_page (modification) by focusing on creation of new records.

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

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

The description provides clear context for when to use this tool ('to add new entries such as tasks, projects, notes, etc. to any database'), but does not explicitly state when not to use it or name specific alternatives. It implies usage for creation vs. update_page for modifications, but lacks explicit exclusions or comparisons.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively explains that deletion is actually an archive operation in Notion, can be restored later, and implies it's a destructive action (though reversible), adding crucial context beyond basic functionality.

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

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

The description is front-loaded with the core action and key behavioral details in the first sentence, followed by a practical usage example. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.

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

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

For a destructive tool with no annotations and no output schema, the description does well by explaining the archive behavior and reversibility. However, it could improve by mentioning permissions or side effects, but given the simplicity (one parameter) and clear behavioral context, it is largely complete.

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

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

The schema description coverage is 100%, with the parameter 'pageId' fully documented in the input schema. The description does not add any additional meaning or details about the parameter beyond what the schema provides, so it meets the baseline for high schema coverage without extra value.

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

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

The description clearly states the specific action ('Deletes (archives) a Notion page') and resource ('page (database record)'), distinguishing it from siblings like update_page or get_page. It provides precise terminology about Notion's archive behavior, 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.

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

The description includes explicit usage context ('Use this to organize completed tasks, finished projects, etc.'), which helps guide when to apply the tool. However, it does not specify when to use alternatives like update_page for modifications or explicitly state exclusions, leaving some room for improvement in sibling differentiation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates this is a read operation ('Retrieves'), which is helpful. However, it doesn't mention authentication requirements, rate limits, error conditions, or whether the database must be accessible to the user. The description adds some behavioral context but leaves important operational details unspecified.

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

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

The description is perfectly concise with two sentences that each earn their place. The first sentence states the purpose and what's returned, while the second provides clear usage guidance. There's zero wasted language or redundancy.

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

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

For a single-parameter read operation with no output schema, the description provides good coverage of purpose, return values, and usage context. It could be more complete by mentioning authentication or error handling, but given the tool's simplicity and the absence of annotations/output_schema, it's reasonably comprehensive.

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

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

The schema description coverage is 100%, so the schema already fully documents the single parameter (databaseId with format examples). The description adds no additional parameter information beyond what's in the schema, so it meets the baseline for high schema coverage without adding extra value.

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

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

The description clearly states the specific action ('Retrieves detailed information'), target resource ('specific Notion database by its ID'), and distinguishes from siblings like list_databases (which lists databases) and get_page (which retrieves page information). It provides concrete details about what information is returned.

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

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

The description provides clear context for when to use this tool ('to understand database structure'), which implicitly distinguishes it from siblings like list_databases (for listing databases) and query_pages (for querying database contents). However, it doesn't explicitly state when NOT to use it or name specific alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses that it retrieves detailed information and lists specific return types (properties, timestamps, archive status), which adds behavioral context beyond a basic read. However, it doesn't cover aspects like error handling, permissions required, rate limits, or whether it's idempotent, leaving gaps for a tool with no annotation support.

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

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

The description is a single, well-structured sentence that front-loads the core action ('Retrieves detailed information') and efficiently lists return details without redundancy. Every part adds value, and there's no wasted text, making it highly concise and clear.

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

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

Given the tool has no annotations and no output schema, the description provides a good overview of purpose and returns, but it lacks details on error cases, authentication needs, or response format specifics. For a read operation with one parameter, it's adequate but not fully complete, as more behavioral context would help compensate for the missing structured data.

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

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

Schema description coverage is 100%, so the schema already fully documents the single parameter (pageId with format and example). The description adds no additional parameter semantics beyond what's in the schema, such as how to obtain the ID or edge cases. This meets the baseline of 3 when schema coverage is high.

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

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

The description clearly states the verb ('Retrieves') and resource ('specific Notion page'), specifies it's for detailed information, and distinguishes it from siblings like query_pages (which likely returns multiple pages) and get_database (which targets a different resource type). It explicitly mentions what information is returned, making the purpose specific and differentiated.

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

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

The description implies usage by specifying it retrieves a 'specific' page by ID, suggesting it's for when you have a known page ID. However, it doesn't explicitly state when to use this versus alternatives like query_pages (for searching/filtering) or list_databases (for different resources), nor does it mention prerequisites or exclusions. The guidance is present but not comprehensive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the return format ('ID, title, creation time, and archive status') and the scope ('accessible to the integration'), which are useful. However, it lacks details on permissions, rate limits, pagination, or error handling, leaving some behavioral aspects unclear for a 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.

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

The description is two sentences, front-loaded with the core purpose and followed by usage guidance. Every sentence adds value: the first specifies what the tool does and what it returns, and the second provides context for when to use it. There is zero waste or redundancy.

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

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

Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is reasonably complete. It covers the purpose, return data, and usage context. However, without annotations or an output schema, it could benefit from more behavioral details (e.g., pagination, error cases), slightly reducing completeness for a read operation.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the inputs. The description adds no parameter-specific information, which is expected. According to the rules, 0 parameters baseline is 4, as there is nothing to compensate for, and the description does not contradict the schema.

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

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

The description clearly states the specific action ('Lists all Notion databases'), specifies the resource ('accessible to the integration'), and distinguishes it from siblings like 'get_database' (which retrieves a specific database) and 'query_pages' (which queries pages within databases). The verb+resource combination 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.

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

The description provides clear context for when to use this tool ('to discover available databases'), which implicitly distinguishes it from siblings that require a specific database ID (e.g., 'get_database', 'update_database') or perform mutations (e.g., 'create_page'). However, it does not explicitly state when NOT to use it or name alternatives, keeping it at a 4.

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

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

No annotations are provided, so the description carries the full burden. It mentions filtering and sorting but lacks details on permissions, rate limits, pagination behavior (beyond cursor hints in schema), error handling, or what 'retrieves pages' entails (e.g., format, fields returned). For a query 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.

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

The description is appropriately sized and front-loaded with the core purpose, followed by examples that reinforce usage. However, the last sentence ('Retrieve pages matching specific conditions') is somewhat redundant with the first part, slightly reducing efficiency.

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

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

Given no annotations and no output schema, the description is incomplete for a complex query tool with 5 parameters and nested objects. It covers the basic purpose and examples but lacks details on behavioral traits, return values, and comprehensive usage guidelines, leaving the agent with gaps in understanding.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by mentioning 'supports filtering and sorting' and giving general examples, but does not provide additional syntax or format details. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('queries and retrieves') and resources ('pages from a Notion database'), and distinguishes it from siblings by focusing on querying rather than creating, deleting, or updating pages. The examples further clarify the scope.

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

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

The description implies usage through examples like 'tasks with status In Progress' but does not explicitly state when to use this tool versus alternatives such as 'get_page' for single pages or 'list_databases' for listing databases. No explicit exclusions or prerequisites are provided.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It correctly identifies this as a mutation operation ('Updates'), but doesn't mention permission requirements, whether changes are reversible, potential side effects, or error conditions. The description adds some context about what gets modified but lacks comprehensive behavioral details.

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

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

The description is perfectly front-loaded with the core purpose in the first sentence, followed by clarification of scope and explicit alternative tool guidance. Every sentence earns its place with no wasted words, making it highly efficient for agent comprehension.

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

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

For a mutation tool with no annotations and no output schema, the description provides adequate purpose and usage guidance but lacks details about behavioral implications, error handling, or return values. It's complete enough for basic selection but insufficient for full operational understanding without additional context.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters. The description mentions 'database title or update schema' which aligns with the schema parameters but doesn't add meaningful semantic context beyond what's already in the structured schema descriptions.

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

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

The description clearly states the specific action ('Updates the database itself'), distinguishes it from updating individual records, and explicitly differentiates from sibling tool 'update_page'. It specifies what can be changed (title or schema) with concrete examples of schema modifications.

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

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

The description provides explicit guidance on when to use this tool vs alternatives: 'To update individual records, use update_page instead.' This directly addresses the most likely confusion point with sibling tools and establishes clear boundaries for tool selection.

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

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

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it's a mutation operation ('Updates'), supports individual or multiple property updates, and lists all supported property types with examples. However, it doesn't mention permission requirements, rate limits, or error conditions.

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

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

The description is efficiently structured: first sentence states the core purpose, second explains scope and capability, third provides concrete examples. Every sentence earns its place with no wasted words, and it's appropriately sized for a complex tool.

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

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

For a mutation tool with no annotations and no output schema, the description does well by explaining what the tool does, what parameters mean, and providing extensive examples. However, it doesn't describe the return value or error conditions, leaving some gaps in completeness.

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

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

With 100% schema description coverage, the baseline is 3, but the description adds significant value by explaining the 'properties' parameter's purpose ('object containing properties to update'), providing comprehensive examples of property type formats, and clarifying that updates can be individual or multiple. This goes well beyond what the schema provides.

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

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

The description clearly states the tool's purpose with specific verb ('Updates') and resource ('properties of a Notion page/database record'), distinguishing it from siblings like create_page, delete_page, get_page, and update_database. It specifies the scope ('ALL property types') and provides concrete examples of what can be updated.

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

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

The description implies usage through examples ('change status to "Completed", update progress to 80%') but doesn't explicitly state when to use this tool versus alternatives like create_page for new pages or update_database for database properties. No explicit 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.