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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool adds observations to existing entities, implying a mutation operation, but doesn't cover critical aspects like permissions needed, whether changes are reversible, rate limits, error handling (e.g., if entities don't exist), or what the response looks like (since no output schema exists). This leaves significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every element ('Add new observations', 'to existing entities', 'in the knowledge graph') contributes directly to understanding the tool's function.

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 is a mutation operation (adding data) with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., idempotency, side effects), error conditions, or response format, which are critical for an AI agent to use it correctly in a knowledge graph context with many sibling 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 description coverage is 100%, so the schema fully documents the single parameter 'observations' and its nested structure (entityName, contents). The description adds no parameter-specific details beyond implying the tool works on existing entities, which is already suggested by the schema's entityName field. This meets the baseline for high 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 clearly states the action ('Add new observations') and target ('to existing entities in the knowledge graph'), providing a specific verb+resource combination. It distinguishes from obvious siblings like 'delete_observations' and 'upsert_entities', though it doesn't explicitly contrast with all potential alternatives like 'update_relations' which might also modify graph content.

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. It doesn't mention prerequisites (e.g., entities must exist), exclusions (e.g., cannot create new entities), or direct comparisons to siblings like 'upsert_entities' (which might handle entity creation) or 'update_relations' (which modifies different graph elements).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Mark as completed' implies a mutation operation, but it doesn't specify whether this is reversible, what permissions are required, how it affects task status, or what happens if the task is already completed. This leaves critical behavioral aspects undocumented.

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

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

The description is extremely concise with a single sentence that directly states the tool's purpose. There's no wasted words or unnecessary elaboration, making it front-loaded and efficient for quick understanding.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'completed' means in this context, what the tool returns (e.g., success confirmation, updated task object), or error conditions. Given the complexity of task management and rich sibling toolset, more context is needed.

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

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

The description doesn't mention any parameters, but schema description coverage is 100% with a single well-documented 'id' parameter (UUID of the task). This meets the baseline of 3 since the schema adequately covers parameter semantics, though the description adds no value beyond what's already in the structured data.

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

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

The description clearly states the action ('Mark as completed') and resource ('task'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'update_tasks' or 'list_tasks' which might also handle task completion, leaving some ambiguity about why this specific tool exists.

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 like 'update_tasks' or 'list_tasks'. There's no mention of prerequisites (e.g., task must exist, be in progress), exclusions, or typical scenarios for completion versus other task operations.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool creates relations, implying a write operation, but lacks critical details: it doesn't specify permissions needed, whether relations are immutable after creation, error handling for duplicate relations, or what the response contains. The active voice requirement is noted, but overall behavioral context is insufficient for a mutation tool.

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

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

The description is extremely concise with two sentences that directly address the tool's function and a key constraint. It's front-loaded with the core purpose and avoids any unnecessary elaboration, making it efficient and easy to parse without wasted words.

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

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

Given the complexity of a write operation to a knowledge graph with no annotations and no output schema, the description is incomplete. It fails to explain what happens upon success (e.g., returns created relation IDs), error conditions, or side effects. For a tool that mutates graph data, this leaves significant gaps in understanding how to use it effectively.

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 fully documents the 'relations' parameter and its nested structure. The description adds minimal value beyond this, only implying that relations are 'multiple' and 'new', which is redundant with the schema. No additional semantics about parameter constraints or usage are provided, meeting the baseline for high 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 clearly states the action ('Create multiple new relations') and the target resource ('between entities in the knowledge graph'), which is specific and actionable. It distinguishes from siblings like 'delete_relations' and 'update_relations' by focusing on creation, though it doesn't explicitly contrast with 'upsert_entities' which might overlap. The active voice requirement adds nuance but doesn't fully differentiate from all 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?

The description provides no guidance on when to use this tool versus alternatives. It mentions 'relations should be in active voice', which is a constraint rather than usage context. There's no indication of prerequisites, when to choose this over 'upsert_entities' or 'update_relations', or any exclusions, leaving the agent to infer based on tool names alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it correctly indicates this is a destructive operation ('Delete'), it doesn't mention important behavioral aspects like whether deletions are permanent/reversible, what permissions are required, whether there are rate limits, what happens to orphaned relations, or what the response looks like. For a destructive operation with zero annotation coverage, 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 a single, efficient sentence that communicates the core purpose without any wasted words. It's appropriately sized for a tool with one parameter and gets straight to the point with no unnecessary elaboration.

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

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

For a destructive operation with no annotations and no output schema, the description is incomplete. It doesn't address critical context like error conditions, confirmation requirements, side effects on related data, or response format. Given the complexity of deleting entities with associated relations in a knowledge graph, more behavioral context is needed for safe and effective 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?

Schema description coverage is 100%, so the schema already fully documents the single parameter 'entityNames'. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., format examples, constraints on entity names, batch size limits). With complete schema coverage, the baseline score of 3 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 action ('Delete') and target resources ('multiple entities and their associated relations from the knowledge graph'), providing specific verb+resource information. However, it doesn't explicitly distinguish this tool from sibling tools like 'delete_observations' or 'delete_relations', which handle different resource types in the same system.

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. There are multiple sibling deletion tools (delete_observations, delete_relations) that handle different resource types, but the description doesn't explain when this specific entity deletion tool is appropriate versus those alternatives or mention any prerequisites or constraints for its use.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Delete' implies a destructive mutation, the description doesn't specify whether deletions are permanent, reversible, require specific permissions, or have side effects on related data. It also doesn't describe what happens if referenced entities or observations don't exist, or what the tool returns upon completion.

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, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for a tool with one parameter and good schema documentation, though it could benefit from additional context about usage and behavior.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is inadequate. It doesn't address critical behavioral aspects like permanence, error handling, or return values. Given the complexity of modifying a knowledge graph and the presence of multiple deletion-related sibling tools, more context about when and how to use this tool is needed.

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

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

Schema description coverage is 100%, so the schema already fully documents the 'deletions' parameter structure. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain what constitutes an 'observation', provide examples of observation values, or clarify the relationship between entities and their observations.

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

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

The description clearly states the action ('Delete') and target ('specific observations from entities in the knowledge graph'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish itself from sibling tools like 'delete_entities' or 'delete_relations', which handle different deletion operations in the same knowledge graph context.

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 like 'delete_entities' (which deletes entire entities) or 'delete_relations' (which deletes relationships). There's no mention of prerequisites, constraints, or typical scenarios where deleting observations would be appropriate versus other deletion operations.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Delete' implies a destructive operation, it doesn't specify whether deletions are permanent, reversible, require specific permissions, or have side effects on connected entities. For a destructive tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a tool with a clear name and well-documented schema, making it easy for an agent to parse quickly.

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

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

For a destructive tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after deletion, whether there are confirmation steps, error conditions, or what the return value contains. Given the complexity of modifying a knowledge graph, more contextual information would be helpful.

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 100% description coverage, thoroughly documenting the 'relations' parameter and its nested structure. The description adds no parameter information beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the action ('Delete') and resource ('multiple relations from the knowledge graph'), making the purpose immediately understandable. It distinguishes from sibling tools like 'delete_entities' by specifying relations rather than entities, though it doesn't explicitly contrast with 'update_relations' or 'create_relations'.

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 like 'update_relations' or 'delete_entities'. It doesn't mention prerequisites, consequences, or typical scenarios for deleting relations, leaving the agent to infer usage context from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions sourcing via an API but doesn't cover critical aspects like rate limits, authentication needs, error handling, or what the output looks like (e.g., structured answer with citations). For a tool with external API calls and no annotations, this is a significant gap.

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, efficient sentence that directly states the tool's function without any wasted words. It's appropriately sized and front-loaded, making it easy to grasp quickly.

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

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

Given the complexity of an external API tool with no annotations and no output schema, the description is incomplete. It doesn't explain the return format (e.g., how citations are structured), potential limitations, or error cases, leaving gaps for an agent to invoke it correctly in varied contexts.

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 both parameters ('question' and 'max_citations') with details like minLength, default, and range. The description adds minimal value beyond implying the question is for sourcing answers, but doesn't provide additional syntax or format insights beyond what the schema offers.

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

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

The description clearly states the action ('Ask a question and get a sourced answer') and the resource/method ('via Exa /answer API'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'exa_search' or 'memory_query', which might also retrieve information, so it lacks sibling distinction for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'exa_search' and 'memory_query' that could serve similar information-retrieval purposes, there's no mention of context, prerequisites, or exclusions to help an agent choose appropriately.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Search the web' implies a read-only operation, but it doesn't disclose important behavioral traits like rate limits, authentication requirements, error handling, response format, or whether it performs live web searches versus cached results. The description is too minimal for a tool with 9 parameters.

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 - a single 6-word sentence that states the core purpose without any fluff. It's front-loaded and wastes no words, though this conciseness comes at the cost of completeness.

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 complex web search tool with 9 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what kind of results to expect, how they're formatted, whether there's pagination, or any behavioral constraints. The minimal description fails to provide adequate context for effective tool 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?

The description adds no parameter-specific information beyond what's already in the schema (which has 100% coverage). It doesn't explain how parameters interact, provide usage examples, or clarify semantics like what 'neural' search means versus 'keyword'. With complete schema coverage, the baseline is 3, but the description doesn't add meaningful 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 action ('Search the web') and the resource/API being used ('using Exa API'), which is specific and unambiguous. It doesn't explicitly distinguish from sibling tools like 'exa_answer' or other search-related tools, but the verb+resource combination is clear enough for basic understanding.

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 like 'exa_answer' (which appears to be a sibling tool) or other search-related tools in the list. There's no mention of use cases, prerequisites, or comparisons with similar 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?

No annotations are provided, so the description carries full burden. It mentions optional filtering but doesn't disclose behavioral traits like pagination, rate limits, authentication needs, or what happens with no parameters (e.g., lists all tasks). For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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, efficient sentence that front-loads the core purpose ('List tasks') and adds essential detail ('with optional filtering'). Every word earns its place with no redundancy or fluff, making it easy to parse quickly.

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, no output schema, and a read operation with filtering, the description is incomplete. It doesn't explain return values (e.g., task list format), error conditions, or practical usage context. For a tool with 2 parameters and behavioral uncertainty, more information would help the agent use it effectively.

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 both parameters ('priority' and 'status') fully documented in the schema including enum values. The description adds minimal value by noting filtering is optional but doesn't provide additional semantics beyond what the schema already states. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('List') and resource ('tasks'), making the purpose immediately understandable. It distinguishes from siblings like 'update_tasks' or 'next_task' by focusing on listing rather than modifying or selecting. However, it doesn't explicitly differentiate from other listing tools (none present in siblings), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, compare to siblings like 'search_nodes' or 'memory_query', or specify scenarios where filtering is beneficial. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a query operation but doesn't describe what the tool returns (e.g., format, structure), whether it's paginated, if there are rate limits, authentication requirements, or error conditions. The phrase 'advanced filters' is too vague to provide meaningful behavioral insight.

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 sentence that efficiently states the core function. However, it could be more front-loaded with critical context (e.g., what type of data is queried). There's no wasted text, but it may be too brief given the tool's complexity and lack of annotations.

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 6 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'memory store' contains, what format results return, or how this differs from other query tools. For a query tool with multiple parameters and siblings offering similar functionality, more context is needed to guide proper usage.

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 all 6 parameters are documented in the schema. The description adds no additional parameter information beyond what's already in the schema (e.g., it doesn't explain how filters combine, precedence, or special syntax). Baseline score of 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Query the memory store with advanced filters' states a general purpose (querying) but is vague about what specific resource is being queried. It mentions 'memory store' but doesn't clarify if this refers to observations, entities, tasks, or other data types available in the system. Compared to siblings like 'search_nodes' or 'read_graph', the distinction is unclear.

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_nodes', 'read_graph', or 'show_memory_path'. The description mentions 'advanced filters' but doesn't specify what makes this tool different from other query/search tools in the sibling list. There's no mention of prerequisites, limitations, 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 provided, the description carries the full burden. It discloses key behavioral traits: it retrieves a task and changes its status to 'in-progress,' indicating a mutation. However, it lacks details on permissions, side effects (e.g., if marking affects other tasks), or error handling, leaving gaps for a tool that modifies state.

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, front-loaded sentence that efficiently conveys the tool's purpose and action without unnecessary words. Every part earns its place by specifying what is retrieved and how it is modified.

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

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

Given the tool's complexity (a mutation with no annotations and no output schema), the description is minimally adequate. It explains the core action but lacks details on return values, error cases, or how 'highest priority' is determined. For a state-changing tool, more context would improve completeness.

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

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

The input schema has one parameter with 100% coverage, describing it as a 'Dummy parameter for no-parameter tools.' The description adds no parameter-specific information, but since the tool effectively has zero functional parameters, this is acceptable. A baseline of 4 is appropriate as the description doesn't need to compensate for missing param details.

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

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

The description clearly states the specific action: 'Get the next highest priority todo task and mark it as in-progress.' It uses precise verbs ('get' and 'mark') and identifies the resource ('todo task'), distinguishing it from siblings like 'list_tasks' (which likely lists without marking) and 'complete_task' (which marks as completed).

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 context by specifying 'next highest priority,' suggesting it should be used when prioritizing tasks sequentially. However, it does not explicitly state when not to use it (e.g., vs. 'list_tasks' for viewing without marking) or name alternatives, keeping it from a perfect score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('open') but doesn't clarify what 'open' entails operationally—whether it retrieves node details, validates existence, or requires permissions. No information on rate limits, error handling, or output format is given, which is a significant gap for a tool with potential read/mutation implications.

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, efficient sentence with zero wasted words. It front-loads the core action and resource, making it easy to parse. Every word contributes directly to understanding the tool's purpose without redundancy or 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?

Given the lack of annotations and output schema, the description is incomplete for effective tool use. It doesn't explain what 'opening' nodes returns, how errors are handled, or behavioral traits like idempotency. For a tool interacting with a knowledge graph, more context on operational semantics is needed to compensate for missing structured data.

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

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

The description adds minimal semantic context beyond the input schema, which has 100% coverage. It implies that 'names' refers to entity names in the knowledge graph, but doesn't elaborate on format, uniqueness, or handling of invalid names. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't significantly enhance parameter understanding.

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

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

The description clearly states the action ('open') and target resource ('specific nodes in the knowledge graph'), with the qualifier 'by their names' adding specificity. It distinguishes from siblings like 'search_nodes' (searching) and 'read_graph' (reading entire graph), though not explicitly. However, 'open' is somewhat ambiguous compared to more precise verbs like 'retrieve' or 'access'.

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 is provided. The description implies usage for retrieving nodes by exact names, but it doesn't specify prerequisites, exclusions, or compare to siblings like 'search_nodes' (for fuzzy matching) or 'read_graph' (for broader access). This leaves the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'Generates IDs and syncs with knowledge graph', which adds some behavioral context beyond basic creation. However, it doesn't cover critical aspects like whether this is a write operation (implied but not stated), error handling, permissions needed, or what 'syncs' entails in practice.

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

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

The description is concise with two sentences that directly state the purpose and key behaviors. It's front-loaded with the main action and avoids unnecessary details. However, it could be slightly more structured by explicitly separating purpose from side effects.

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

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

Given no annotations and no output schema, the description is incomplete for a tool that creates multiple tasks. It doesn't explain what is returned (e.g., success status, created task IDs), error conditions, or how the knowledge graph sync works. For a write operation with potential complexity, this leaves significant 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 100%, so the schema fully documents the 'tasks' parameter and its nested properties. The description adds no additional parameter semantics beyond what's in the schema, such as explaining the structure or usage of the 'tasks' list. This meets the baseline for high 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 clearly states the action ('Create multiple tasks from a plan') and the resource ('tasks'), with additional context about generating IDs and syncing with a knowledge graph. However, it doesn't explicitly differentiate from sibling tools like 'list_tasks' or 'update_tasks', which would require more specific scope or usage context.

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. For example, it doesn't specify whether this is for bulk creation versus single-task creation (if such a tool exists), or when to use it over 'update_tasks' or 'list_tasks'. The description lacks context about prerequisites or typical scenarios.

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

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

With no annotations, the description carries full burden but provides minimal behavioral insight. It mentions 'entire knowledge graph' but doesn't disclose performance implications (e.g., may be slow for large graphs), output format, or error conditions. The placeholder parameter 'dummy' is unexplained in the description, leaving the agent guessing about its 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 a single, efficient sentence that states the core function without fluff. However, it could be more front-loaded with critical details (e.g., 'Read all entities and relationships from the knowledge graph') to improve clarity. It earns its place but misses optimization opportunities.

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

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

Given no annotations and no output schema, the description is incomplete for a tool that presumably returns complex graph data. It doesn't explain what 'entire' includes (e.g., nodes, edges, properties), potential size limits, or return structure. For a read operation with undefined output, this leaves significant gaps for 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?

Schema description coverage is 100%, with the single parameter 'dummy' documented as a placeholder that doesn't require input. The description doesn't add parameter details beyond the schema, but since there are effectively 0 functional parameters, the baseline is 4. No compensation is needed for gaps.

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 the action ('Read') and resource ('knowledge graph'), but lacks specificity about what constitutes 'entire' - does it return all nodes, edges, metadata, or a summary? It doesn't clearly distinguish from sibling tools like 'search_nodes' or 'memory_query' which might also retrieve graph information. The purpose is understandable but vague in 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 is provided on when to use this tool versus alternatives like 'search_nodes' or 'memory_query'. The description implies it retrieves everything, but doesn't specify use cases (e.g., for overviews, bulk analysis) or warn against misuse (e.g., for large graphs). This leaves the agent without context for tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Search') but doesn't describe what 'nodes' entail, how results are returned (e.g., format, pagination), or any constraints like rate limits or authentication needs. For a search tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy to parse quickly. Every word earns its place by conveying essential 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?

Given the complexity of a search operation with no annotations and no output schema, the description is incomplete. It doesn't explain what 'nodes' are in this context, how results are structured, or any behavioral traits like error handling. For a tool that likely returns data, the lack of output details makes it inadequate for full understanding.

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

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

Schema description coverage is 100%, with the single parameter 'query' documented as 'Search query to find matching entities'. The description adds no additional meaning beyond this, such as query syntax examples or what constitutes a 'matching entity'. With high schema coverage, the baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.

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 ('Search') and resource ('nodes in the knowledge graph'), making the purpose immediately understandable. It distinguishes from some siblings like 'add_observations' or 'delete_entities' by focusing on retrieval rather than modification. However, it doesn't explicitly differentiate from similar search tools like 'exa_search' or 'memory_query', which slightly limits sibling differentiation.

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. It doesn't mention when to choose 'search_nodes' over 'exa_search', 'memory_query', or other search-related siblings, nor does it specify prerequisites or exclusions. This leaves the agent without context for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns a path but doesn't clarify if this is a read-only operation, whether it requires specific permissions, or what happens if no active file exists. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that front-loads the core purpose without any wasted words. It directly communicates what the tool does in a clear and structured manner, making it easy to parse quickly.

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 (no functional parameters, no output schema, no annotations), the description is adequate but minimal. It explains the basic purpose but lacks context about the knowledge-graph system, error conditions, or return format, which could help an agent use it more effectively in complex scenarios.

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

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

The tool has 0 required parameters and 1 dummy parameter with 100% schema description coverage, so the schema fully documents the input structure. The description appropriately adds no parameter details, as none are needed, aligning with the baseline for zero functional 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 the specific action ('Return absolute path') and the resource ('active knowledge-graph file'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'read_graph' or 'memory_query' by focusing solely on file path retrieval rather than content manipulation or querying.

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 like 'read_graph' or 'memory_query', nor does it mention prerequisites or exclusions. It lacks context about the active knowledge-graph file's role in the system, leaving usage entirely implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the tool 'will not obtain new information or change the database, but just append the thought to the log,' which covers read-only and non-destructive behavior. It also mentions memory/cache functionality and provides guidance on thought structure. However, it doesn't address potential limitations like rate limits, authentication needs, or error conditions.

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

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

The description is appropriately sized but could be more front-loaded. The first sentence clearly states the purpose, but the second sentence contains important behavioral information that should be more prominent. The guidance on thought structure is helpful but could be more concise. Overall, it's adequate but not optimally structured.

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

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

For a complex tool with 14 parameters and no output schema, the description provides good context about the tool's purpose, behavioral characteristics, and usage patterns. It covers the key aspects of what the tool does and when to use it. However, without annotations or output schema, it could benefit from more explicit information about return values or error handling.

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 14 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. It only mentions general structural elements like 'problem definition' and 'analysis steps' which loosely map to the structuredReasoning parameter. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Use the tool to think about something' and specifies it 'will not obtain new information or change the database, but just append the thought to the log.' This distinguishes it from research tools like exa_search and database mutation tools like upsert_entities. However, it doesn't explicitly differentiate from other reasoning tools like plan_tasks or memory_query.

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

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

The description provides clear usage context: 'Use it when complex reasoning or some cache memory is needed.' It also offers structural guidance with 'Consider including: problem definition, relevant context, analysis steps, self-reflection on your reasoning, and conclusions.' However, it doesn't explicitly state when NOT to use this tool or mention specific alternatives among the sibling 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?

No annotations are provided, so the description carries full burden. It states 'update' implying mutation, but lacks critical behavioral details: what permissions are required, whether changes are reversible, how errors are handled (e.g., if a relation doesn't exist), or rate limits. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its operation and risks.

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, efficient sentence that front-loads key information ('update multiple existing relations') without unnecessary words. Every part earns its place by specifying the action, scope, and resource concisely, making it easy to parse quickly.

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 (a mutation tool for a knowledge graph), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling, permissions, or return values, leaving the agent with insufficient context to use it safely and effectively. More detail is needed to compensate for the missing structured data.

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

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

Schema description coverage is 100%, with the 'relations' parameter fully documented in the schema (including nested 'from', 'to', 'relationType' fields). The description adds no additional meaning beyond implying batch updates via 'multiple', which is already clear from the array type in the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('update') and resource ('multiple existing relations in the knowledge graph'), making the purpose immediately understandable. It distinguishes from siblings like 'create_relations' (for new relations) and 'delete_relations' (for removal), but doesn't explicitly contrast with 'upsert_entities' which might handle similar graph modifications. The specificity is good but could be slightly more comparative.

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. It doesn't mention prerequisites (e.g., relations must exist), contrast with 'create_relations' for new relations or 'upsert_entities' for entity-level updates, or specify scenarios like batch updates. Without such context, an agent might misuse it or overlook better options.

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

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

With no annotations provided, the description carries full burden but only states it 'updates multiple tasks with new values'. It doesn't disclose behavioral traits like whether updates are atomic, require specific permissions, what happens on partial failures, or if there are rate limits. For a mutation tool with zero annotation coverage, this is a significant gap.

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, efficient sentence that front-loads the core action. It avoids redundancy and wastes no words, though it could be slightly more informative without losing conciseness.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what values can be updated, the response format, error handling, or dependencies. Given the complexity of bulk updates and lack of structured data, more context is needed for effective 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?

Schema description coverage is 100%, so the schema fully documents the 'updates' parameter and its nested fields (id, description, due, priority, status, tags). The description adds no additional meaning beyond implying bulk operations, which is already evident from the schema's array structure. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb ('update') and resource ('multiple tasks') with the scope of applying 'new values'. It distinguishes from siblings like 'complete_task' or 'list_tasks' by specifying bulk updates. However, it doesn't explicitly differentiate from 'update_relations' or other update operations.

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 'complete_task' for single updates or 'plan_tasks' for task planning. The description lacks context about prerequisites, such as needing existing task IDs, or when bulk updates are appropriate versus individual operations.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'upsert pattern' but doesn't disclose key behavioral traits: it doesn't specify what happens on conflicts (e.g., whether updates merge or replace data), authentication needs, rate limits, or error handling. The description is minimal and lacks operational details critical for a mutation tool.

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

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

The description is a single, efficient sentence that front-loads the core purpose. It avoids redundancy and waste, though it could be slightly more informative without losing conciseness. Every word earns its place, making it appropriately sized for the tool's complexity.

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

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

Given the tool's complexity (a mutation operation with no annotations and no output schema), the description is incomplete. It doesn't cover behavioral aspects like side effects, response format, or error conditions. For an upsert tool that modifies a knowledge graph, more context is needed to guide safe and effective 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?

Schema description coverage is 100%, so the schema fully documents the single parameter 'entities' and its nested properties. The description adds no additional meaning beyond the schema, such as explaining the 'upsert' logic in more detail or providing examples. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('Create new entities or update existing ones') and resource ('in the knowledge graph'), and specifies the pattern ('using an upsert pattern'). It distinguishes from siblings like 'create_relations' or 'delete_entities' by focusing on entity creation/updates, though it doesn't explicitly contrast with 'add_observations' or 'update_relations' which might handle related but different operations.

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. It doesn't mention when to prefer 'upsert_entities' over 'add_observations' for adding data, or 'delete_entities' for removal, nor does it specify prerequisites or contextual cues for upsert operations. Usage is implied by the term 'upsert' but not explicitly defined.

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