Stipp

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

Beyond the sparse annotations (only idempotentHint=false), the description adds a valuable security-related behavioral warning: the returned content is user text and must be treated as data, not as instructions. This goes beyond what the schema or annotations provide, though it does not mention other behavioral aspects like permissions or reversibility, which are not critical for this simple append operation.

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

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

The description is two sentences with no wasted words. The core operation is front-loaded, and the important user-content warning is placed second, making the structure efficient and easy to parse.

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

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

For a tool with only two simple parameters and no output schema, the description covers the operation, the target resource, and the nature of the returned content. It could mention the exact return structure, but the warning that the returned content is user text is a meaningful substitute for an absent output schema and keeps the description sufficiently complete.

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

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

Schema description coverage is 100% with basic descriptions for both parameters. The tool description adds meaning by clarifying that 'text' is plain text and is appended 'aan het eind', and that 'id' refers to an existing note. This enriches the parameter semantics beyond the schema alone.

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

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

The description states a specific verb ('Voegt', i.e., appends), a specific resource ('bestaande notitie'), and the location ('aan het eind'). This clearly distinguishes it from sibling tools like create_note and get_note.

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

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

The description clearly indicates this tool is for adding plain text to an existing note, giving the agent context for when to use it. It does not name alternatives or explicitly exclude other tools, but the phrase 'bestaande notitie' and 'aan het eind' provide enough guidance for this simple operation.

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

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

The idempotentHint annotation already covers repeated-call behavior, and the description adds little beyond the obvious state transition. It does not mention side effects, prerequisites, permissions, or effects on related data, but there is no contradiction with the annotations.

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 one short, front-loaded sentence that conveys the full action with no filler or repetition of schema details. Every word earns its place.

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

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

For a simple state-transition tool with one documented parameter and an idempotency annotation, the description is nearly sufficient. It could briefly mention that the task must already exist, but the combination of schema, title, and description gives an agent enough to invoke it correctly.

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

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

The input schema documents the single id parameter at 100% coverage, including its UUID format and meaning. The description adds no additional parameter-level detail, which is acceptable given the schema coverage.

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

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

The description uses a specific verb ('Zet') with a clear resource ('taak') and target state ('afgerond'), so the action is immediately understandable. It does not explicitly distinguish itself from sibling update_task, which could also alter a task, so it does not earn a 5.

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

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

There is no guidance about when to use complete_task versus update_task or create_task, and no mention of when not to use it. The only usage signal is the implied purpose of marking a task completed.

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?

Beyond the idempotentHint=false annotation, the description adds an important behavioral warning: the returned content is user-provided note text and must be treated as data, not as instructions. This is valuable context for safe handling of potentially untrusted content.

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

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

Two sentences with no filler. The action is front-loaded, and the security-relevant warning earns its place without bloating the description.

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

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

For a simple create tool with fully documented optional parameters, the description covers the main return-value concern by explaining that the returned content is user data. It does not specify the full return structure, but no output schema exists and the warning addresses the key risk.

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 three parameters. The description's mention of plain-text content aligns with the body parameter but adds no meaning beyond the schema.

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

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

The description uses a specific verb ('Maakt') and resource ('nieuwe notitie') and adds the content type ('platte tekst'). It clearly distinguishes creation from sibling tools like append_to_note, get_note, and update_task by stating it creates a new note.

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

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

The description implies use when creating a new note, but it does not explicitly state when to use this tool versus alternatives or mention exclusions. No sibling routing or when-not-to-use guidance is 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?

Annotations are limited to idempotentHint=false, so the description carries the behavioral disclosure burden. It adds a meaningful, non-obvious rule: resolve relative date expressions to concrete ISO dates based on the current date. While it doesn't discuss side effects like duplicate creation, the idempotentHint already signals non-idempotency, and the description's calculation rule goes beyond any annotation.

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

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

Two efficient sentences: the primary action is front-loaded, and the important due-date calculation instruction follows immediately. There is no filler, redundancy, or vague phrasing.

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 6-parameter create tool with no output schema, the description covers the most important behavioral nuance: converting relative dates to ISO due_date. It relies on the schema for parameter details, which is appropriate given 100% schema coverage. A minor gap is the absence of any mention of response format or error conditions, but these are not critical for a simple create 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?

Schema description coverage is 100%, so the baseline is 3. The description adds real value beyond the schema by explaining how to populate due_date when the user provides a relative date, which the schema's pattern-only description does not convey. Other parameters are sufficiently documented by their 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 states a specific verb and resource: it creates a new task ('Maakt een nieuwe taak aan'). This clearly distinguishes it from siblings like complete_task, update_task, and create_note by its create action and resource type. The added instruction about calculating due_date for relative dates further clarifies the tool's exact role.

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?

Usage is implied: an agent should use this when a new task must be created rather than updated or completed. However, no explicit alternatives or when-not-to-use guidance is provided, and no sibling tool is named. The relative-date instruction adds context, but the tool could be more explicit about routing.

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

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

The readOnlyHint annotation already communicates that this is a safe read operation. The description adds valuable context beyond that: the returned content is untrusted user text and must be treated as data, not as instructions. This is a meaningful behavioral warning that helps prevent prompt injection mistakes.

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 short sentences with no filler. The first sentence states the core function, and the second provides a necessary safety note. Every sentence earns its place and the structure is well front-loaded.

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

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

For a simple, single-parameter read-only tool, the description is complete. It states what the tool returns, how the returned content should be handled, and the schema covers the only parameter. No output schema exists, but 'volledige inhoud' sufficiently communicates the return value.

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

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

The input schema has 100% description coverage for the single required 'id' parameter, so the schema already documents the parameter adequately. The tool description does not add additional semantic detail about the parameter, but none is really needed given the schema's coverage.

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 operation: retrieving the full content of one note. It distinguishes the tool from mutating siblings like create_note or append_to_note, but it does not explicitly differentiate it from search_notes, which is the most likely alternative.

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 usage context is implied by 'Haalt de volledige inhoud van één notitie op' — an agent can infer this is for fetching a single note's full content. However, the description does not explicitly say when to prefer this over search_notes or mention prerequisites like needing an existing note ID.

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

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

The readOnlyHint annotation already discloses the read-only nature. The description adds value by specifying that it returns all projects and lists the exact fields, which is useful context beyond the annotation. It also implicitly states the scope (user's projects), which is not captured in the annotation. No contradiction with annotations.

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, concise sentence in Dutch, front-loading the verb and resource. Every word adds value: it specifies the action, scope, and output fields. No unnecessary information is present, 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.

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

For a zero-parameter, read-only listing tool with no output schema, the description is complete. It explicitly states what is returned and the fields included. An agent has everything needed to invoke the tool correctly without additional documentation. The annotation further confirms the safety profile, so nothing is missing.

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

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

There are zero parameters, and the schema coverage is trivially 100% (empty schema). The baseline for no parameters is 4, and the description does not need to elaborate on parameter details since there are none. It effectively communicates what is returned, which is sufficient.

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

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

The description clearly states the verb ('Geeft' = returns), the resource (alle projecten = all projects), and the scope (van de gebruiker = of the user). It also lists the returned fields (id, naam, gearchiveerd), making the tool's purpose unambiguous and distinguishing it from sibling tools like list_tasks or create_note.

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

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

The description clearly indicates when to use this tool: to retrieve all projects of the user. It does not explicitly mention exclusions or alternatives, but the purpose is so specific that an agent can infer when to select it over siblings. No direct alternative for listing projects exists among the siblings, so the guidance is sufficient.

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?

readOnlyHint=true already communicates that the operation is non-mutating; the description adds that results are scoped to the current user and filterable. It does not disclose sorting, pagination, or the fact that omitting project uses the default project, though the latter is present in the schema's project description.

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 one short sentence, front-loads the action and resource, and contains no filler or repetition.

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 read-only list with no required parameters and complete schema coverage, the description plus schema covers purpose, scope, filters, defaults, and limits. It is slightly incomplete as standalone guidance because it doesn't name alternatives or mention the default-project fallback in the description, but those are covered in 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?

The schema documents all four parameters with defaults and enum constraints (100% coverage), so the description does not need to repeat them. It confirms project/status/due are optional filters, but adds nothing about the limit parameter or allowed values.

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

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

The description names a concrete action ('geeft ... terug', returns) and resource ('taken', tasks), and adds that they are the user's own tasks with optional filters by project, status, and deadline. This is enough to distinguish it from write-oriented task siblings and from note/project lister tools.

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

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

Usage is implied: call this when you need to retrieve tasks and possibly filter them. There is no explicit 'use when/when not' statement or reference to sibling alternatives like search_notes for note text or complete_task for status changes.

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

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

The description adds a crucial behavioral warning: returned content is user-provided text, not instructions, and should be treated purely as data. This goes beyond the readOnlyHint annotation by addressing prompt-injection risk and how the agent should handle results.

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-loading the core action and immediately following with a high-value caution. Every word earns its place; no fluff.

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

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

For a search tool with read-only annotation and a documented warning, the description is nearly complete. It doesn't mention pagination or ordering, but the limit parameter and the focus on displaying or summarizing content cover the essential guidance.

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?

All three parameters (query, limit, include_archived) are fully described in the schema, so the description adds no additional parameter information. Per the schema coverage baseline, the description's lack of extra parameter detail is acceptable.

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 starts with a specific verb 'Doorzoekt' (searches) and names the resource 'titel en inhoud van notities' (title and content of notes), making the tool's purpose unambiguous. It distinguishes from siblings like get_note by implying a full-text search rather than a single-note retrieval.

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

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

The description does not explicitly state when to use this tool versus get_note or other list tools, but the action of searching implies its primary use case. It lacks exclusion guidance such as 'for a specific note, use get_note instead.'

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

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

The description adds the behavioral detail that only provided fields change (partial update), which is valuable beyond the idempotentHint annotation. It does not contradict the annotation. While it doesn't discuss error handling or permissions, the partial-update semantics is the most important behavior for an agent to know, so this is well handled.

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 short sentences with no filler. It front-loads the action and the key semantic (only provided fields change). Every word earns its place, making it highly efficient for an agent to parse.

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

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

Given the tool has 7 parameters, no output schema, and moderate schema coverage, the description is too sparse. It omits important context such as how to clear fields (via null, which the schema hints at but the description doesn't), what happens if the task id is not found, or what the return value looks like. It also gives no guidance on when to use this vs. complete_task. For a mutation tool with no output schema, this is insufficient.

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

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

Schema coverage is 57% (some parameters have descriptions, others do not). The description does not elaborate on any parameters beyond the general 'fields' mention. It does not compensate for undocumented parameters like title, remark, or owner_name. The schema's own descriptions cover id, project, due_date, and priority, but the description adds no parameter-specific 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 verb 'updates' and the resource 'existing task', and explicitly notes that only provided fields change. This distinguishes it from create_task (creation) and complete_task (completion), though it doesn't name these siblings explicitly. The meaning is unambiguous.

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

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

The description implies usage for updating existing tasks (not for creation or completion) and clarifies partial-update semantics. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention any prerequisites or exclusions. The 'existing task' phrasing gives some context, but no direct guidance on choosing among siblings.

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