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

No annotations are provided, so the description bears full responsibility for disclosing behavioral traits. However, it only documents input parameters and does not describe side effects, authentication needs, or what happens on success or failure. Key behavioral aspects like whether duplicate titles are allowed or if area_title must match an existing area are only implied.

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

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

The description is well-structured with a clear opening sentence followed by a bulleted list of parameters. It is front-loaded and each parameter earns its place. While slightly verbose in listing all args, the format aids readability. One minor point: the 'Args' section could be trimmed, but overall efficient.

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

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

Given the tool has 8 parameters, 0% schema coverage, no annotations, and an output schema exists, the description provides thorough input documentation. It covers all parameters with explanations and critical formatting notes. The output schema presumably handles return values. One gap is lack of error conditions or constraints, but overall complete enough for an experienced user.

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

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

Schema description coverage is 0%, meaning the schema provides no parameter descriptions. The tool's description compensates fully by explaining each parameter's purpose and format, including critical details like 'tags must be an array of strings' and 'area_title must exactly match an existing area title.' 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.

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

The description clearly states 'Create a new project in Things.' This verb+resource combination is specific and immediately distinguishes the tool from sibling tools like add_todo or update_project.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like update_project or add_todo. It does not state prerequisites, exclusions, or typical use cases.

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

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

With no annotations, the description carries the full burden. It discloses important behavioral traits: the array vs string pitfall for tags, and the priority rule between list_id and list_title. It does not mention idempotency, duplication behavior, or error handling for invalid list_title, but the note to look up lists mitigates some risk.

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

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

The description is well-structured with a one-line summary followed by a bullet-point argument list. Each line is necessary and informative. It front-loads the purpose and uses clear formatting.

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

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

Given the presence of an output schema (not shown but known to exist), the description does not need to explain return values. It covers parameter constraints, usage guidance, and key behavioral notes. For a creation tool, this is sufficiently complete.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It explains all parameters: title (implied), notes, when (with valid values), deadline (format), tags (with critical format warning), list_id and list_title (with usage and priority). This adds significant value beyond the bare schema.

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

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

The description starts with 'Create a new todo in Things.' This is a clear and specific verb (Create) + resource (todo) statement. It distinguishes this tool from siblings like update_todo or get_todos by specifying the action and target.

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 guidance on using list_id vs list_title, including priority and the need to look up existing areas/projects with get_areas or get_projects. It also warns about tags format. However, it does not explicitly compare this tool to siblings like add_project or when to use alternative tools for different tasks.

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 the tool returns an extensive list, which is a behavioral trait. However, it does not explicitly state whether it is read-only, destructive, or any authentication requirements. The description is adequate but lacks depth.

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 wasted words: first sentence states purpose, second provides usage guidance and alternatives. Front-loaded and efficient.

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

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

For a parameterless tool with an output schema, the description is mostly complete. It explains what it returns (list of tasks), warns about volume, and suggests alternatives. Could mention pagination or ordering, but overall sufficient.

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

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

There are no parameters (0), so the baseline is 4. The description does not add parameter semantics, but none are needed since the schema is empty and coverage is 100%.

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 gets all todos from the Anytime list. The verb 'Get' and resource 'all todos from Anytime list' are specific. It distinguishes from siblings like get_todos and search_todos by warning about extensive results and recommending alternatives.

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

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

Explicitly recommends using get_todos with filters or search_todos instead, providing clear guidance on when not to use this tool and naming 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?

Describes the effect of the include_items parameter but does not disclose read-only nature or other behavioral traits; no annotations provided so description carries burden.

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

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

Extremely concise: two sentences and an args block. Every sentence adds value. No redundancy.

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

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

Complete for the tool's simplicity: explains purpose, parameter, and usage context. Output schema exists, so return format need not be detailed. Lacks explicit sibling differentiation.

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?

Explains the single parameter include_items: 'Include projects and tasks within areas', adding meaning beyond the schema's boolean name. Satisfactory compensation for 0% schema description 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?

Clearly states it gets all areas from Things and mentions usage for assignment. Distinguishes from sibling tools like get_projects by focusing on areas, but does not explicitly differentiate.

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

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

Implies when to use (for obtaining area names for assignment), but provides no guidance on when not to use or alternatives among siblings.

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

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

Description does not disclose behavioral traits such as read-only nature, side effects, or access permissions. With no annotations, the description should provide more context.

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

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

Extremely concise with no wasted words. The single sentence is efficient and front-loaded.

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

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

Given zero parameters and an output schema present, the description is adequate for a simple retrieval tool. However, it could mention the sorting or filtering behavior.

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?

No parameters exist, so schema coverage is complete. Description adds no parameter info, but none is needed.

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 'Get todos from Inbox' clearly states the action and resource. It distinguishes from siblings like 'get_today' or 'get_anytime' by specifying 'Inbox', but could be more explicit about 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?

No guidance on when to use this tool versus alternatives (e.g., 'get_todos'). There are no exclusions or context provided.

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

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

No annotations provided, so description carries full burden. It discloses default behavior (7 days, 50 limit) but omits explicit statements about being read-only, idempotent, or any side effects. Sufficient for simple read operation.

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

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

Extremely concise, front-loaded with purpose, followed by two-line parameter breakdown. Every sentence is necessary and informative with no redundancies.

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 tool with two optional parameters and an output schema, the description covers the core functionality and parameters. Lacks explanation of what 'Logbook' is (e.g., a history of completed items), but this is minor given sibling 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 coverage is 0%, so description adds vital meaning: explains period format (e.g., '3d', '1w', '2m', '1y') and limits default. However, no additional constraints on limit (e.g., maximum) or explanation of period units beyond examples.

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

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

Description clearly states verb 'Get' and resource 'completed todos from Logbook', with a default scope of last 7 days. Unambiguous and distinct from sibling tools like get_todos (all todos) or get_recent (recently modified).

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

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

No explicit when-to-use or when-not-to-use guidance. The description implies usage for retrieving completed tasks over a period, but does not exclude alternatives or provide context like when to prefer get_todos or get_recent.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states 'Get all projects from Things,' implying a read operation, but does not mention authentication requirements, whether projects are mutable, or how the data is structured. The behavior is minimally conveyed.

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

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

The description is extremely concise at two sentences, making it quick to parse. The first sentence provides the core purpose, and the second documents the parameter. However, it could be structured better with a clear separation of description and parameter details.

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

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

For a simple one-parameter tool with an output schema, the description is minimally adequate. It explains the tool's main action and parameter, but lacks context about the scope of 'all projects' (e.g., user-specific or global), no mention of ordering or pagination, and no guidance on expected return format beyond what the output schema might provide.

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

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

The schema coverage is 0%, so the description must add meaning. It explains the 'include_items' parameter as 'Include tasks within projects,' which clarifies its purpose beyond the schema's default and title. However, it does not specify what 'include' means structurally (e.g., nested tasks or a separate tasks array), leaving room for ambiguity.

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

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

The description clearly states 'Get all projects from Things,' specifying the verb 'Get,' the resource 'projects,' and the scope 'all.' This effectively distinguishes it from siblings like 'add_project' and 'update_project,' which are mutative, and from other retrieval tools like 'get_today' or 'get_inbox.'

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'search_todos' or 'get_areas.' It lacks any context about prerequisites, limitations, or scenarios where this tool is appropriate.

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

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

No annotations are provided, so the description carries full responsibility. It discloses that the tool returns a random subset and does not filter types, but it does not state that it is read-only, any side effects, or behavior on invalid inputs. Adequate but not thorough.

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

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

The description is concise, with five lines including a helpful note. No unnecessary words or repetition. Efficiently communicates the core functionality.

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

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

Given the tool has one parameter and an output schema (not provided for review), the description covers the basic purpose but lacks comparative context with 23 sibling tools. It is adequate but not fully enriched for an agent to confidently select among alternatives.

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

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

Schema description coverage is 0%, so the description should add meaning beyond the schema. It restates the 'count' parameter as 'Number of random items to return. Defaults to 5.' which exactly matches the schema, providing no additional semantics like min/max or special behavior.

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

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

The description clearly states 'Get a random sample of items from the Anytime list' with specific verb 'Get' and resource 'random sample from Anytime list'. It notes that the list can contain both todos and projects, distinguishing it from siblings like get_random_inbox and get_random_todos.

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

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

The description mentions that it returns a random subset without filtering types, which implies when to use (e.g., for a mixed sample). However, it provides no explicit guidance on when not to use or comparisons with alternative tools like get_random_inbox or get_random_todos.

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 mentions random sampling but does not disclose whether the tool is read-only, any side effects, or behavioral nuances. Since no annotations are provided, the description carries full burden; it provides basic transparency but omits details about safety or consistency.

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

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

The description is short and front-loaded with the main purpose. However, the 'Args:' section with delimiter lines adds unnecessary verbosity. It could be more streamlined without losing clarity.

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

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

Given the tool's low complexity (1 non-required parameter, no annotations, output schema exists), the description sufficiently covers the purpose and parameter. It does not explain the output structure, but the output schema likely covers that. The description is adequate for this 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?

The description adds significant value to the parameter 'count' by explaining 'Number of random items to return. Defaults to 5.' This exceeds the schema which only provides type and default; schema coverage is 0%, so the description fully compensates.

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

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

The description clearly states 'Get a random sample of todos from Inbox,' specifying the verb 'get', resource 'todos from Inbox', and the random sampling nature, effectively distinguishing it from siblings like get_inbox and get_random_todos.

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

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

The description explains the default behavior of the count parameter but does not explicitly state when to use this tool versus alternatives such as get_inbox or get_random_anytime. It is clear in its context but lacks explicit usage boundaries.

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. The description transparently explains it returns a random sample with a default count, but does not disclose whether the operation is read-only or other behavioral traits like idempotency.

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 well-structured docstring with an Args section. It is concise and front-loaded with the purpose. Minor redundancy could be trimmed.

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

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

Given the two parameters and no annotations, the description covers the core functionality adequately. The output schema exists, so return values are documented elsewhere. Slight room for improvement in behavioral details.

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

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

With 0% schema coverage, the description compensates by explaining the purpose of each parameter (project_uuid and count) including their default values, adding significant meaning beyond the schema.

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

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

The description clearly states 'Get a random sample of todos' with an optional filter, which is specific and distinguishes it from siblings like get_todos (which gets all todos) and other random getters.

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 over alternatives like get_todos or get_random_anytime. It implies usage for random sampling, but lacks direct guidance 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, description should disclose behavioral traits. It mentions period examples but lacks details on return order, limits, or whether unsaved items are included. Adequate for a simple tool but incomplete.

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

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

Very short and front-loaded with purpose, then parameter explanation. The 'Args: ---' format is informal but efficient. No wasted sentences.

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

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

Given the existence of an output schema, return values need not be explained. However, with many sibling tools and no annotations, the description could provide more context on scope (e.g., across all projects) and differences from similar tools.

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

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

Schema coverage is 0%, so description must compensate. It explains the period parameter with example values but no format specification, default, or validation rules. Minimal added 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 'Get recently created items', specifying verb and resource. It is distinct from siblings like get_today or get_todos, but does not clarify which item types are included (e.g., projects, todos).

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

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

No guidance on when to use vs. alternatives such as get_today, get_upcoming, or get_anytime. The period parameter is given examples but no context on selection criteria.

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

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

The description only states the basic functionality without disclosing any behavioral traits such as read-only nature, pagination, ordering, or permissions. Given no annotations, the description carries the full burden of transparency, and it falls short.

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 that immediately states the action and resource. Every word is necessary.

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

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

The description is minimal but functional. However, given the large number of sibling get_* tools, the description could benefit from a sentence explaining what distinguishes the Someday list from others. The presence of an output schema might compensate for return values, but the description does not hint at the structure.

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

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

The tool has no parameters, so the input schema is trivially fully covered. The description does not need to add parameter semantics. Baseline score 4 is appropriate.

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

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

The description uses a specific verb 'Get' and resource 'todos from Someday list' which clearly indicates the tool retrieves todos from a specific list. It distinguishes itself from sibling tools like get_today, get_inbox, etc. that target different lists.

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 offers no explicit guidance on when to use this tool vs alternatives like get_anytime or get_inbox. The name 'Someday' implies it's for a specific list, but without explanation, an AI agent might not understand the difference.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states that it gets items with a tag, omitting details like pagination, ordering, case-sensitivity, or whether it returns all types of items. Minimal behavioral context.

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

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

Very concise (one sentence plus arg list). No fluff. However, the 'Args:' header is unnecessary for a single param, but overall structure is efficient.

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

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

Considering the tool's simplicity (1 param) and that an output schema exists, the description is still incomplete. It doesn't clarify what 'items' are (todos? projects?) or provide examples. An output schema may define return structure, but the meaning of filtered items remains ambiguous.

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

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

The single parameter 'tag' is described as 'Tag title to filter by', which clarifies it's a title not an ID. Since schema property lacks a description (0% coverage), this adds some value but no format details or possible values. Baseline 3 due to low 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?

Description clearly states the verb 'Get' and resource 'items with a specific tag'. It distinguishes from siblings like get_tags (which returns tags) and other getters that filter by different criteria. However, it doesn't specify what 'items' includes (todos, projects, etc.), which could be ambiguous.

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

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

No guidance on when to use this tool versus alternatives like search_todos or get_projects. The description only states what it does, not the context of use or when to avoid it. There are many sibling tools without differentiation hints.

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

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

No annotations are provided, and the description lacks behavioral details such as pagination, ordering, authentication requirements, or error handling. It only restates the parameter purpose.

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

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

The description is very concise, consisting of a single line and a simple parameter note. It is front-loaded with the core purpose, though the args format is slightly informal.

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

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

Given the existence of an output schema and the tool's simplicity, the description provides basic completeness. However, it lacks context on when to set include_items to true and does not mention any potential scope or limits (e.g., all tags in the system).

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

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

Schema description coverage is 0%, but the description adds 'Include items tagged with each tag,' which clarifies the parameter's meaning beyond the schema's title and default value. However, no additional parameter details are provided.

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

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

The description clearly states 'Get all tags,' which is a specific verb-resource pair. It distinguishes itself from siblings like 'get_tagged_items' by focusing on tags themselves, not tagged items.

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

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

No guidance on when to use this tool versus alternatives like 'get_tagged_items' or 'search_items.' The description does not mention any prerequisites, exclusions, or typical use cases.

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

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

With no annotations, the description must disclose behavioral traits, but it only states the basic function. It does not mention whether results include completed tasks, recurrences, sort order, or timezone handling.

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

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

The description is very concise (5 words) and front-loaded. However, it may be too sparse given the need to differentiate from many similar sibling tools.

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 absence of parameters and the presence of an output schema, the description is minimally adequate. It explains the basic purpose but lacks details about edge cases (e.g., overdue items) and does not fully differentiate from siblings.

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 no parameters, so by rule the baseline is 4. The description adds no parameter details because none exist.

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 'Get todos due today' clearly specifies the verb 'Get' and the resource 'todos due today', which distinguishes it from sibling tools like get_anytime (anytime tasks) or get_upcoming (future tasks). It is specific and unambiguous.

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

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

No guidance is provided on when to use this tool vs alternatives such as get_todos or get_upcoming. The description lacks context for 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?

No annotations are provided, so the description must fully convey behavior. It only states 'Get todos from Things' without detailing output format, pagination, authentication, or read-only nature. This is insufficient for an unannotated tool.

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

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

The description is concise: one sentence stating purpose and one parameter description. It is front-loaded and contains no superfluous information.

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

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

For a simple tool with one optional parameter and an output schema, the description covers the basics. However, it omits context about output structure or usage prerequisites, which would be helpful given the lack of annotations.

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

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

The schema has 0% description coverage, but the description includes an 'Args' section explaining project_uuid as an optional UUID. This adds meaning beyond the schema type definition, though the UUID format could be more specific.

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 retrieves todos from Things with optional project filtering. However, it does not explicitly differentiate from siblings like search_todos, which could be used for similar purposes.

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

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

The description implies usage when fetching todos, optionally filtered by project, but provides no guidance on when to use this over siblings like get_anytime or search_todos. No exclusions or alternatives are mentioned.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states 'Get trashed todos' without explaining what 'trashed' means, whether it's a read operation, or any side effects. This is insufficient.

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

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

The description is extremely concise at two words, but it lacks sufficient context. It could be improved by adding a brief explanation of what 'trashed' means or how the results are sorted.

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

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

The tool is simple with no parameters and has an output schema, so the description could be minimal. However, it does not clarify the scope (e.g., all trashed items or just todos) or any default ordering, which would help the agent.

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

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

There are no parameters in the input schema. The description does not need to add parameter semantics, and the baseline score for 0 parameters is 4, which is appropriate.

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

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

The description clearly states the verb 'Get' and resource 'trashed todos', indicating it retrieves deleted items. However, it does not distinguish from sibling tools like get_inbox or get_todos, which could be confusing.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_inbox or get_todos. The context signals show many sibling tools, but the description offers no selection criteria.

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

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

No annotations exist, so the description carries the full burden. It discloses the filter criteria (future start date) but does not mention ordering, pagination, or exact time boundary. The output schema may fill some gaps, but the description alone is minimal.

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

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

The description is a single, well-structured sentence that immediately conveys the tool's purpose without redundant words.

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

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

Given the tool's simplicity (zero parameters, no nested objects), the description is largely complete. However, it omits details like default ordering or whether the result set is limited, which would be useful for an AI agent.

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

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

No parameters exist; schema coverage is 100% by default. The description adds meaning by clarifying the scope ('start date in the future'), which qualifies as helpful context beyond the empty schema.

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

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

The description clearly states 'Get all upcoming todos' and defines 'upcoming' as those with a start date in the future. This is a specific verb-resource pair and distinguishes from siblings like get_today or get_recent.

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

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

No explicit when-to-use guidance or alternatives are provided. The tool's purpose implies usage for future-dated todos, but with many siblings, explicit guidance would help.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only lists parameters; it does not state whether this tool is read-only, whether it respects user context, what the default behavior is when no filters are given (returns all?), or any side effects. This lack of transparency could lead to misuse.

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

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

The description is concise (two sentences plus parameter list). However, the parameter list uses raw 'Args:' formatting with dash bullets, which is functional but not polished. It could be more structured (e.g., table or enumerated list). No extraneous words, but some parameter descriptions are ambiguous (e.g., 'tag' as a string but not clear if it's exact match).

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

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

Given the complexity (6 optional parameters) and many sibling tools, the description is incomplete. It does not explain how filters combine (AND, OR?), whether all parameters are optional and what an empty search returns, or how pagination works. An output schema exists (not shown), but the tool's behavior remains underdefined.

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

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

Schema description coverage is 0%, so the description bears full responsibility for parameter meaning. It adds basic descriptions (e.g., 'Filter by todo status (incomplete/completed/canceled)'), which clarify purpose. However, it does not specify expected formats (e.g., UUID for area, date format for start_date/deadline). The parameter list is minimally helpful but not comprehensive.

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 'Advanced todo search with multiple filters' which clearly identifies the action (search) and resource (todos). The listed parameters (status, start_date, etc.) reinforce this. However, it does not explicitly differentiate from sibling search tools like 'search_items' or 'search_todos', leaving the agent to infer from the 'advanced' name.

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

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

The description provides no guidance on when to use this tool versus its many siblings. It does not specify prerequisites, alternative tools, or exclusions. The agent must guess from the name and parameter list, which is insufficient for correct 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?

No annotations are provided, so the description must fully disclose behaviors. It only says 'Search for items in Things,' which reveals nothing about authentication needs, rate limits, mutation risks, or response characteristics. This is severely insufficient.

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

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

The description is extremely short (one sentence), but it fails to provide necessary information. While concise, it is under-specified and does not earn its place; it sacrifices completeness for brevity.

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

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

Given the presence of sibling tools and no annotations, the description should elaborate on scope, behavior, and output. It does not mention what is returned, pagination, or limitations, making it incomplete even for a simple search tool.

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

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

The input schema has 0% description coverage, meaning neither schema nor description adequately explains parameters. The description adds only 'query: Search query,' which simply repeats the parameter name without clarifying format, constraints, or examples.

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 'Search for items in Things,' which is a clear verb+resource. However, it lacks differentiation from sibling tools like search_todos and search_advanced, which also search but likely in more specific scopes. The term 'items' is vague and could encompass multiple entity types.

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

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

No guidance is provided on when to use this tool versus alternatives like search_todos or search_advanced. The description does not mention any context, prerequisites, or exclusions, leaving the agent without decision support.

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

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

No annotations provided; description carries full burden. It reveals that the tool searches both title and notes, but omits details like case sensitivity, partial matching, pagination, or response structure. Minimal behavioral disclosure.

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

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

Extremely concise: one-line summary plus a single parameter doc. No unnecessary words, front-loaded with purpose. Efficient 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's simplicity (one param, output schema present), the description is adequate but leaves gaps: no mention of matching behavior (exact/substring), result limits, or ordering. Could be more 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?

With 0% schema description coverage, the description adds valuable meaning: 'Search term to look for in todo titles and notes.' This clarifies that the query applies to both fields, which the schema's 'Query' title alone does not convey.

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

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

The description clearly states 'Search todos by title or notes', specifying the verb, resource, and search scope. It distinguishes from sibling tools like 'search_advanced' or 'search_items' which may target different fields or use more complex logic.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies usage for basic text search on todos, but fails to mention when not to use it (e.g., for filters or advanced queries) or list alternative tools.

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

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

With no annotations, the description partially covers behavior: it mentions the format constraint for filter_tags and the special id values. However, it lacks details on error handling, authentication, or side effects, leaving 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 concise, front-loaded with purpose, and uses a structured Args section. The filter_tags instruction, though lengthy, is important for correctness. No unnecessary content.

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

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

The description covers purpose and parameter details adequately but lacks usage guidance and behavioral context (e.g., invalid ID handling). Given the presence of an output schema, return value explanations are not needed. Overall, adequate but with gaps.

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

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

Schema description coverage is 0%, and the description adds critical meaning: it enumerates special id values, explains query as optional filtering, and gives a crucial note on filter_tags array format. This significantly aids correct usage.

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

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

The description clearly states 'Show a specific item or list in Things' and lists the special IDs (inbox, today, etc.), distinguishing it from sibling get_* tools that only fetch specific lists. However, it does not explicitly differentiate itself from those 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?

The description provides no guidance on when to use show_item versus alternatives like get_today or get_inbox. It lists possible id values but does not explain trade-offs or exclusions.

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

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

No annotations are provided, so the description bears full burden. It includes important behavioral notes: tags must be array not string, list_name restrictions (cannot move to Inbox/Logbook), and how to move to Logbook via completed. However, it does not disclose error behavior or return value 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 front-loaded with purpose and uses a structured 'Args' section. It is slightly verbose due to detailed parameter notes, but every sentence adds value.

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

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

Despite 11 parameters and no annotations, the description covers all parameters with behavioral constraints. It lacks information about what happens on invalid id or error conditions, but output schema likely handles return values.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter's meaning. It provides valid values for 'when', warns about 'tags' array format, enumerates allowed 'list_name' values, and clarifies area parameters.

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

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

The description clearly states 'Update an existing project in Things,' specifying the verb (update) and resource (project). It distinguishes from sibling tools like add_project (create) and update_todo (update todos), 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 does not explicitly state when to use this tool vs alternatives like add_project. It provides some parameter-specific guidance (e.g., list_name constraints) but lacks general when-to-use context.

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

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

No annotations exist; description covers basic update behavior but lacks details on partial vs full update, side effects, or authentication. It does warn about tags format and list_id priority.

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

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

Description is front-loaded with purpose and structured as a list; each sentence adds value. Slight redundancy on list_id priority but overall efficient.

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

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

Given no annotations and output schema present, description covers all parameters adequately. Missing details on idempotency or return format, but not critical for update use.

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

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

With 0% schema coverage, description fully compensates by explaining each parameter's meaning, valid values (e.g., 'when' options), formatting constraints (tags as array), and priority rules (list_id over list_name).

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 'Update' and the resource 'existing todo in Things', distinguishing it from sibling tools like add_todo (create) and update_project (project update).

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 implicitly clear (update an existing todo), but no explicit guidance on when not to use or alternatives is provided. The parameter descriptions offer some usage hints (e.g., list_id vs list_name priority).

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