ContextStream MCP Server

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

The description claims read-only behavior, but annotations have readOnlyHint=false, creating a direct contradiction. Additionally, it does not explain how operations are specified or any error behaviors, leaving key behavioral aspects undisclosed.

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 only two sentences, no redundancy, and front-loaded with the core action. Every word 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 no output schema and no parameters, the description lacks details on how to specify the operations to batch, what happens on error, and any limits (e.g., max batch size). This leaves the agent with insufficient information to use the tool correctly.

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

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

The input schema has no parameters (0 params), and schema coverage is 100%. Per guidelines, 0 params yields a baseline of 4. The description adds no parameter information 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 clearly states the tool executes multiple independent read-only operations in one call, which is a specific verb+resource. It further distinguishes itself from siblings by explicitly rejecting write or destructive operations, making its 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 states when to use the tool (for multiple independent read-only operations) and what it rejects (writes/destructive operations). However, it does not explicitly name alternative tools or provide guidance on when not to use it beyond the rejection statement.

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 annotations declare readOnlyHint=true and destructiveHint=false, but the description includes mutating actions like create, share, delete, revoke_share, which contradict the read-only hint. This is a serious inconsistency that could mislead the agent. The description itself is detailed but contradicts the annotations.

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

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

The description is relatively long but front-loaded with the core purpose and usage guidelines. It uses a list of use cases which is easy to scan. Some redundancy exists (e.g., explaining share behavior multiple times), but overall it is well-structured for the 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 has 33 parameters and 15 actions, the description covers intended usage scenarios and defaults. However, it lacks explanation of return values (no output schema) and does not fully detail all actions. It relies on the schema for parameter details but provides enough context for agent decision-making.

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 100%, so baseline is 3. The description does not add significant meaning beyond the per-parameter descriptions in the schema, though it provides some context on defaults (e.g., max_uses, expires_in_days). The description does not repeat parameter 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 tool's purpose: 'portable, shareable, hydrate-on-demand snapshots of project context.' It lists specific use cases (pasting /c/<token> link, handoff requests, etc.) and explicitly distinguishes from the sibling tool 'context' (normal turn-by-turn retrieval).

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

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

The description provides explicit when-to-use scenarios (e.g., user pastes a capsule token, asks for handoff/share link, wants to bootstrap a fresh agent) and an explicit when-not-to-use (normal retrieval should use context). It also details behavior of different share types (authenticated team links vs token-gated single-use public/external links).

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

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

Annotations are minimal (no readOnly, destructive, etc.). The description only says 'Create' without disclosing side effects, required permissions, or behavior beyond the obvious.

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 focused sentence. However, it could be expanded to include essential context without becoming verbose.

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?

With 10 parameters, no output schema, and many siblings, the description is severely incomplete. It fails to explain what an implementation plan is, required relationships (e.g., project_id?), or post-creation 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?

Schema descriptions cover 100% of parameters, but they are generic ('Input parameter: tags.'). The description adds no extra meaning, so baseline 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 states 'Create a new implementation plan' - a clear verb+resource pair. However, it does not explain what an 'implementation plan' is or differentiate from sibling tools like 'memory_create_doc' or 'capsule'.

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 is provided. The description lacks any context for decision-making.

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

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

Annotations already indicate read-only, non-destructive, idempotent behavior. The description adds value by explaining token savings, format details, and background task for saving exchanges. No contradictions.

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 bullet points and an example, but it is somewhat lengthy. It front-loads the key instruction, which is effective.

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?

With 13 parameters and no output schema, the description covers usage, formats, and modes thoroughly. The example provides a concrete workflow, making it complete enough for most use cases.

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 100%, and the description goes beyond by explaining format options, type codes, and the role of parameters like user_message, session_tokens, and mode. This adds significant context.

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: to analyze user messages and retrieve token-efficient context before every AI response. It distinguishes itself from siblings by emphasizing its role in replacing full chat history.

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 explicitly directs 'CALL THIS BEFORE EVERY AI RESPONSE', providing a clear usage guideline. It also explains format and mode options, and gives an example workflow, though it doesn't mention when not to use it.

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 annotations declare readOnlyHint=true, indicating the tool is read-only, but the description explicitly supports write actions (create, update, delete). This is a direct contradiction. Additionally, idempotentHint=true conflicts with the non-idempotent nature of delete. The description fails to disclose behavioral traits beyond the annotations, and the contradiction severely impairs the agent's ability to use the tool correctly.

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, using a single sentence with embedded lists for kinds and actions. Every word serves a purpose, and the structure is front-loaded with the core purpose ('Unified CRUD across taxonomy expansion entities'). No unnecessary information is present.

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 7 parameters, multiple kinds and actions, and no output schema, the description provides basic purpose and parameter default behavior but lacks details on return values, error handling, pagination (for list), or idempotency guarantees. The annotation contradiction further undermines completeness, making it only minimally adequate.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds value by stating that workspace_id and project_id default to the active scope when omitted, and that the body is free-form JSON forwarded to the API. This provides useful behavioral context not present in the schema alone.

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

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

The description clearly states the tool performs CRUD operations on taxonomy expansion entities, listing all supported kinds (ticket, handoff, etc.) and actions (list, get, create, update, delete). This provides a specific verb-resource mapping. However, the term 'taxonomy expansion entities' is somewhat vague and does not distinguish this tool from sibling tools like 'batch_operations' or 'capsule'.

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 gives no explicit guidance on when to use this tool versus alternatives. It does not mention when not to use it, any prerequisites, or suggest sibling tools for different scenarios. The purpose is implied only through the listed actions and entities, leaving the agent to infer appropriate usage.

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

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

Annotations are present and consistent with 'execute' implying mutation. The description adds context about the origin of capabilities but does not disclose additional behavioral traits beyond what annotations already provide.

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 with no unnecessary words or repetition.

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

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

Given zero parameters and no output schema, the description is sufficient for the tool's simplicity, though it could explicitly note the lack of return 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 input schema has no parameters, so schema description coverage is 100%. The description does not add parameter information, but none is needed; baseline for 0 params is 4.

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 specifies a clear verb ('execute') and resource ('hidden or deferred capability returned by tool_search'), which distinguishes it from sibling tools that perform other 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 implies use when a capability is obtained via tool_search, but does not provide explicit guidance on when not to use it or mention alternative tools for similar 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?

The description lists mutating actions like 'push', 'ack', and 'clear', but annotations declare readOnlyHint=true, indicating read-only operations. This is a direct contradiction. Additionally, despite destructiveHint=false, operations like 'clear' are destructive. The tool's behavioral traits are inconsistent with annotations.

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

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

The description is concise, consisting of two short sentences that front-load the key fact (alias of instruct) and then list actions. Every sentence adds value, but the structure could be improved with clearer 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?

Despite the schema covering parameter details, the description lacks essential context about what the instruction cache is, how the actions work, and the relationship to the 'instruct' tool. For a tool with 9 parameters and multiple actions, this leaves significant gaps for an AI agent to understand correct 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?

The input schema has 100% coverage with descriptions for all 9 parameters. The description does not add any additional meaning beyond the schema, so a baseline score of 3 is appropriate. No parameter-specific elaboration is 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 states it is an alias of 'instruct' and specifies 'session-scoped instruction cache operations', listing 8 actions. This clearly identifies the tool's purpose and distinguishes it from sibling tools like 'instruct', though the exact distinction is implied rather than explicit.

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. While it is marked as an alias of 'instruct', there is no explanation of when to prefer 'flash' over 'instruct' or other siblings, nor any mention of prerequisites or limitations.

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 implies file generation but does not explicitly state that files are written to disk or the overwrite behavior. Annotations are all false, and the description does not contradict them. Basic behavioral context is present, but more detail about side effects would improve 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 concise with two sentences, front-loading the core purpose. The list of editors is relevant but somewhat lengthy. No superfluous text, though it could be slightly tighter.

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?

With no output schema, the description should explain return values or success behavior, but it does not. It covers parameter purposes well via schema, but missing output details makes it less complete for a tool with 9 parameters.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal value beyond the schema, only listing editors which are already in the enum. It does not elaborate on parameter usage or constraints.

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 it generates AI rule files for specific editors, listing supported editors explicitly. The verb 'generate' and resource 'editor AI rules' are specific and distinguish it from the sibling 'generate_rules' tool by focusing on editors.

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 'generate_rules'. It lacks explicit context for when or when not to use it, leaving the agent to infer usage from the tool name.

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

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

Annotations are unhelpful (all false). The description does not explicitly state that the tool writes files to disk, which is implied by the name but not confirmed. It mentions 'dry_run' parameter that returns content without writing, but does not disclose the default behavior of overwriting existing files (overwrite_existing parameter).

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 at two sentences, front-loading the main purpose. However, the second sentence includes a long list of editors that is somewhat redundant with the schema, though still acceptable.

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?

With 12 parameters and no output schema, the description lacks details on output format, side effects (file creation/overwrite), and comparison to sibling tools. The tool is relatively complex but the description is too brief to fully inform 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 coverage is 100%, so parameter descriptions are already present. The description adds some context (e.g., editor list, default behavior) but lists editors inconsistently (includes opencode, windsurf, antigravity not in enum). This adds marginal value 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 'Generate AI rule files for editors', and the title adds 'ContextStream rules', making the purpose clear. However, it does not distinguish from the sibling tool 'generate_editor_rules', which likely serves a similar function.

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 minimal guidance: 'Defaults to the current project folder; no folder_path required when run from a project.' It does not specify when to use this tool over the similar 'generate_editor_rules', nor does it mention when not to use it.

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

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

Annotations declare readOnlyHint=true, but the description includes 'ingest (build graph)', which suggests a write operation. This contradiction undermines transparency. The description adds some behavioral context (e.g., action names) but fails to resolve the inconsistency with annotations.

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

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

The description is concise (single line) and front-loads the core purpose. However, the list of actions is run-on; using bullet points or better separation would improve structure. Still efficient with no wasted text.

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 (11 actions, 13 parameters, no output schema), the description is too terse. It does not explain when to use each action, what the return values look like, or how parameters interact. The schema fills many gaps, but the description leaves the agent with insufficient context for correct invocation.

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 100% with detailed descriptions for all 13 parameters. The description adds minimal value beyond the schema by providing glosses for actions (e.g., 'module deps'), which helps interpret the 'action' parameter. Baseline 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 tool is for 'Code graph analysis' and lists 11 distinct actions, each with a brief gloss (e.g., 'dependencies (module deps)'). This makes the purpose specific and differentiates it from sibling tools like 'search' or 'entity'.

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 enumerates the available actions but provides no guidance on when to use this tool over alternatives, nor does it specify prerequisites or when not to use it. The list implies usage contexts, but explicit when-when-not instructions are absent.

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 explains the behavioral context of each action beyond the annotations (readOnlyHint, destructiveHint, idempotentHint). It discloses that actions like 'editor_rules' generate files and install hooks, and 'enable_bundle' modifies tool state, aligning with the idempotent and non-destructive hints.

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 starts with the core purpose and lists actions. It is front-loaded but could benefit from breaking down actions for better readability.

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 16 parameters and multiple actions, the description is insufficient. It lacks details on which parameters apply to which actions, expected outputs, and usage examples. The absence of an output schema further limits 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 100% description coverage for parameters, so the baseline is 3. The description does not add additional meaning beyond the schema; it only lists actions without detailing parameter usage for each.

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 explicitly states 'Utility and help' and enumerates distinct actions (tools, auth, version, etc.), making the tool's purpose clear and differentiating it from sibling tools that are more specialized.

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 lists actions with brief explanations, implying when to use each (e.g., 'tools' for listing available tools, 'auth' for current user). However, it does not explicitly state when not to use this tool or provide 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 tool's behavior: initiates a session, retrieves context, suggests code ingestion. Annotations (readOnlyHint=false) do not contradict; description adds details about semantic search and output fields beyond annotations.

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

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

Description is well-structured with clear sections, but slightly verbose. Could trim redundant details about ingest_recommendation benefits. Good use of examples and emphasis on important points.

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 11 parameters and no output schema, the description covers the main workflow, output contents, and edge cases like context compaction. Lacks information about authentication or error conditions, but overall comprehensive.

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

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

Schema coverage is 100%, so parameters are well-documented. Description adds value by explaining context_hint in depth with an example, and clarifies is_post_compact and skip_project_creation usage. Slightly redundant but helpful.

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 'Initialize a new conversation session' and specifies it's the first tool to call. The verb 'initialize' and resource 'conversation session' are specific and distinguishable from siblings like 'session'.

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 says 'This is the FIRST tool AI assistants should call when starting a conversation.' Provides guidance on using context_hint with the first message and handling ingest_recommendation. Also notes that subsequent messages don't need 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?

The annotations declare readOnlyHint=true, implying read-only operations, but the description lists actions like push, clear, ack, and checkpoint, which modify state. This contradiction undermines transparency. Additionally, the description does not disclose important behavioral traits such as persistence, versioning, or concurrency 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 concise but lacks structure. It efficiently lists actions but does not organize them meaningfully or separate the summary from details. A bulleted list or grouping by operation type would improve 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 complexity (8 actions, 9 parameters, no output schema), the description is insufficient. It fails to explain the purpose of each action, the nature of the instruction cache, error conditions, or return values. This leaves the agent with significant gaps in understanding.

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

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

The input schema has 100% description coverage, so the description does not need to repeat parameter details. However, it adds no extra context about parameter usage interdependencies (e.g., which parameters apply to which actions).

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 identifies the tool's domain ('Session-scoped instruction cache operations') and lists specific actions, making its purpose understandable. However, it could be more precise by stating what the tool achieves overall (e.g., manage instructions) rather than just listing actions.

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 'session' or 'context.' It does not specify when not to use it, such as when direct modifications are not needed.

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?

Contradiction between annotations (readOnlyHint=true) and description (includes create, update actions). Description doesn't reconcile this or add behavioral context beyond listing actions.

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 a single paragraph that is front-loaded with purpose but becomes a dense list of actions and parameters. Some structure via parentheses and commas, but could be more concise.

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 (multiple providers, many actions), the description is incomplete. It omits details like the 'all' provider meaning, conditions for team_activity, and which actions apply to which providers. Schema fills gaps but description lacks 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?

Input schema covers all 25 parameters with descriptions (100% coverage). The description adds context for some actions (e.g., search_pages filtering), but overall parameter semantics are adequately covered by schema.

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

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

The description clearly states the tool is for integration operations with Slack, GitHub, and Notion, listing providers and actions. It distinguishes from siblings which are not integration-focused. However, it bundles many actions into one tool, making it broad.

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 merely lists actions without providing context-specific usage criteria 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?

The description contradicts annotations: readOnlyHint=true is inconsistent with index and delete actions which modify data. The description itself discloses ML processing and output formats, but the contradiction undermines trust.

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 action list and workflow example, but slightly verbose. Front-loads core purpose. Could be trimmed 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 high parameter count (16) and no output schema, the description covers main use cases and provides workflow. However, missing details on error handling, rate limits, and authentication. Adequate but not comprehensive.

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

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

Schema coverage is 100%, baseline 3. The description adds meaningful context beyond schema, e.g., explaining output_format options in detail and accepting friendly aliases for content_type. The example workflow illustrates parameter 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 defines the tool as handling media operations (video/audio/image) with specific actions listed. It distinguishes from sibling tools by focusing on semantic understanding for media, solving a specific problem for tools like Remotion.

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?

Provides a detailed example workflow showing the sequence of actions (index, status, search, get_clip). Clearly indicates when to use each action, but does not explicitly state when NOT to use or 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?

Annotations already declare readOnlyHint, destructiveHint, etc. The description adds context about the persistence model and mentions deletion behavior (delete_all) and batch operations. It does not contradict annotations and adds value beyond them.

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 long and enumerates every action in a run-on list. While front-loaded with purpose, the bulk lacks structure and could be more concise. Many sentences are just action lists.

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 high complexity (50 parameters, many actions, no output schema), the description covers a lot: action categories, parameter purposes, and usage hints. However, it lacks guidance on return values and edge cases, which holds it back from a 5.

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 100%, so the baseline is 3. The description provides some additional context for parameters like delete_all and plan_id, but mostly it groups actions rather than deeply explaining parameter semantics. No major gaps, but also no significant extra meaning.

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 opening sentence clearly defines the tool as persistent memory for docs, runbooks, specs, etc., and explicitly distinguishes it from filesystem tools. The verb+resource is specific and the scope is well-defined.

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

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

The description provides explicit guidance on when to use this tool versus alternatives, e.g., 'use action=search or list_docs/get_doc — NOT filesystem tools' and 'for tickets, bugs... use the entity tool instead'. This differentiates from 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?

Annotations indicate it's not read-only, not idempotent, and not destructive, but the description adds no behavioral context beyond that. It doesn't mention consequences like whether the action is irreversible or if it triggers side effects.

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 and to the point, with no unnecessary words. It could arguably be too brief, but it earns its place by being 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?

With no output schema and only a single line, the description lacks completeness. It does not explain return values, error conditions, or how the optional parameters affect 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?

Schema description coverage is 100%, so parameters are already documented. The description does not add any additional meaning beyond the schema, but baseline 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 ('Mark a todo complete') and identifies the resource (todo). It also provides a cross-reference to the handler, which helps disambiguate from other tools like 'memory_create_todo' or 'memory_update_task'.

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., when to use 'memory_update_task' instead), nor any prerequisites or exclusions provided. The description only states the basic action.

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

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

Annotations are all false, so the description must disclose behavioral traits. It only states 'Create', indicating a write operation, but omits details like idempotency, side effects, or required permissions. Minimal behavioral insight provided.

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—one sentence plus a brief note. It front-loads the main purpose without unnecessary words. While it could be more informative, it is efficient and to the point.

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 8 parameters, no output schema, and complex metadata, the description is insufficient. It lacks details on return values, creation behavior, error conditions, and idempotency, leaving gaps for an AI agent to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description mentions doc type examples, which are already in the schema's doc_type description. It adds no additional meaning beyond what's already documented.

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 explicitly states the verb 'Create' and the resource 'durable doc' with concrete examples (spec, runbook, ADR, RFC). It distinguishes from sibling tools like memory_update_doc and memory_create_task by specifying the action and resource type.

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 ('Create a durable doc') but provides no explicit guidance on when to use this tool versus alternatives or context about prerequisites. The note about the same handler adds minimal direction.

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

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

Annotations already indicate a mutation (readOnlyHint=false) and non-destructive. Description adds no extra behavioral context (e.g., persistence, visibility). Does not contradict annotations.

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

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

Single sentence is concise, but given 8 parameters and nested objects, it is too brief to be effective. Lacks detail needed for a tool with this 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?

No output schema and a vague description. With many siblings and complex parameters, the description fails to explain what a memory event is or what the creation entails, leaving agents underinformed.

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 baseline is 3. The description does not add meaning beyond the schema parameter descriptions.

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

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

Description states verb+resource: 'Create a memory event'. It's clear at a high level but does not differentiate from sibling memory tools (e.g., memory_create_doc, memory_create_task), lacking specificity about what constitutes a 'memory event'.

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. With many sibling tools, the description fails to specify use cases or exclusions, leaving the agent without 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?

Annotations indicate non-read-only and non-destructive, consistent with creation. The description adds no extra behavioral details beyond stating creation, which is already implied. No contradictions, but no additional 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?

Two sentences; first is clear and concise. The second sentence about the internal handler is unnecessary and detracts from 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?

With 10 parameters and no output schema, the description is too brief. It does not explain required fields beyond title, or how the task integrates with projects/workspaces, leaving significant gaps for an 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 coverage is 100%, so baseline is 3. The description mentions optional linking to a plan step, which aligns with plan_step_id and plan_id parameters, but adds minimal meaning beyond schema descriptions.

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

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

The description clearly states the tool creates a project-tracking task and optionally links it to a plan step. It uses a specific verb and resource, though it does not explicitly differentiate from siblings like memory_create_todo.

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. The description lacks context on when a task vs todo or event should be created, and provides no exclusions or comparisons.

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

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

Annotations already indicate the tool is not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds no behavioral context beyond 'Create', leaving the agent unaware of side effects, required authentication, or what happens to existing data. Since annotations are present, the bar is lower, but the description fails to add value.

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, no wasted words. However, the second sentence is a technical note that may confuse rather than clarify. It is concise but could be more helpful by front-loading a clearer purpose instead of the handler detail.

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 high schema coverage, this is a creation tool with 8 parameters and no output schema. The description does not explain what happens after creation (e.g., return value, success indication, or side effects). The agent needs more context to understand the tool's behavior fully.

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 each parameter already has a description. The tool description adds no additional parameter-level meaning. Baseline score is 3, as the description does not compensate for any 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 clearly states 'Create a lightweight todo', which identifies the verb (create) and resource (todo). However, it does not differentiate from sibling tools like 'memory_create_task', which likely creates a similar entity, missing an opportunity to clarify when to use this specific tool.

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. The description only states what it does, without any contextual hints about prerequisites, exclusions, or preferred scenarios. The mention of 'Same handler as memory(action="create_todo")' is a technical implementation detail, not usage guidance.

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

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

Annotations already indicate destructiveHint=true, so the description's 'Delete a doc' is consistent but adds no further behavioral details (e.g., irreversibility, permissions needed). It meets the minimum standard given annotations.

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

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

The description is very concise, consisting of two short sentences. It is front-loaded with the action. No extraneous words, though it could be slightly more informative.

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 lacks important context such as whether deletion is permanent, error handling (e.g., if doc does not exist), or any prerequisites (project/workspace context). Given the destructive nature, more completeness is expected.

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 each parameter having clear descriptions. The tool description adds no additional meaning beyond the schema, so baseline 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 'Delete a doc,' indicating the verb and resource. It is specific but does not differentiate from sibling tools like memory_update_doc; however, the verb 'delete' is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as memory_create_doc or memory_update_doc. The mention of an alternative handler ('Same handler as memory(action="delete_doc")') does not provide 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?

Annotations already indicate mutation (readOnlyHint=false) and not destructive (destructiveHint=false). The description only says 'Update' without adding behavioral details such as whether updates are partial or full replacements, or what happens if the doc does not exist.

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 short with one sentence and a parenthetical. While it earns its place, it could be 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?

With 8 parameters, no output schema, and a mutation operation, the description is insufficient. It does not explain update semantics (e.g., partial vs full overwrite) or provide usage context for the parameters.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific meaning beyond what the schema already provides.

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

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

The description clearly states 'Update an existing doc', which is a specific verb and resource. It distinguishes from creation and deletion siblings, but does not differentiate from other update tools like memory_update_task.

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. No mention of prerequisites (e.g., doc must exist) or context for choosing between update, create, or delete.

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 convey behavioral traits, so the description must compensate. It only states the update action but does not disclose any side effects, permissions, or whether changes are irreversible. The 'destructiveHint' annotation is false, but the description does not clarify this.

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 without extraneous words. It is appropriately concise, though it could be structured with bullet points for 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?

With 12 parameters and no output schema or annotations, the description is insufficient. It does not explain the return value, how required fields are determined (only task_id is required per schema), or that task_id can be a title lookup. More context is needed for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no extra meaning beyond what the schema already provides; each parameter's description in the schema is minimal but present.

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 a task') and specifies the aspects that can be updated ('status, fields, plan linkage'). However, it does not differentiate from sibling tools like memory_create_task or memory_complete_todo beyond the verb '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?

No guidance is provided on when to use this tool versus alternatives, such as memory_create_task for creating tasks or memory_complete_todo for completing todos. The mention of 'Same handler...' is an implementation detail, not usage advice.

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

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

Annotations declare readOnlyHint=true, destructiveHint=false, but the description includes destructive actions like 'delete', 'purge', 'merge', and 'remove_paths' which modify or remove data. This is a clear contradiction. The description does add some detail for purge and forget_local, but fails to reconcile the overall destructive nature.

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 overly long and unstructured, consisting of a bullet list of 18 actions with only some inline explanations. It lacks clear front-loading of essential information. Could be organized into categories or brief descriptions for each action.

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 (23 parameters, many actions, no output schema) and the contradictory annotations, the description fails to provide complete context. It doesn't explain row-level details like action dependencies, parameter relevance per action, or 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?

Schema coverage is 100%, so the schema provides parameter descriptions. The tool description does not add any extra semantic meaning beyond listing actions. No parameter usage context is given. Baseline 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 'Project management' and enumerates 18 specific actions. It's obvious what the tool does, but it's a catch-all for many sub-operations, lacking a single focused verb+resource. However, it distinguishes itself from siblings by covering many project-related actions under one tool.

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

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

There are no guidelines on when to use this tool vs alternatives like workspace, entity, or vcs. For example, it doesn't explain when to use 'merge' vs 'update' or 'purge' vs 'delete'. No when-not-to-use or context is provided.

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

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

Description lists write actions (save_kb, update_kb, delete_kb) but annotations declare readOnlyHint=true, a direct contradiction. Despite other useful details (citations, confidence, feedback), the contradiction severely undermines 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?

Well-structured with sections for intro, usage guidelines, heuristic, actions list, and answer explanation. Front-loaded with purpose. Slightly verbose but each part earns its place.

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

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

Covers all actions, explains knowledge base concept, answer generation, citation format, feedback mechanism. Without output schema, description still provides enough context for the agent to understand return values (grounded answer with citations).

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 100% so baseline is 3. Description adds value by explaining each action's purpose (e.g., 'search: vector-similarity-free listing of prior Q&A'), enhancing understanding of parameter usage beyond 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 it's for asking the workspace/project knowledge base. It distinguishes from sibling tools like 'search' and 'session' by explicitly saying it's for workspace-specific knowledge, not general programming or code-reading.

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?

Extensive when-to-use (workspace-specific knowledge, prior decisions, conventions, runbooks) and when-not-to-use (general programming, things in code, trivial syntax) guidance. Includes a heuristic (~30 seconds stuck) and explicitly says it's not a reflex or last resort.

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 includes mutation actions like 'create' and 'complete', contradicting the readOnlyHint annotation set to true; no additional behavioral traits disclosed.

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 sentence), but lacks essential details such as action-parameter relationships, making it insufficiently informative.

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?

With 14 parameters, six actions, no output schema, and no guidance, the description is woefully incomplete for an agent to invoke the tool correctly.

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

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

Schema covers all parameters with descriptions, but the tool's description adds no extra meaning or contextual grouping, so baseline score applies.

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 it manages reminders and lists specific actions, but does not differentiate between the tools' purpose from siblings beyond the 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?

No guidance on when to use each action or how to choose between this tool and alternatives; the description merely enumerates actions without 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?

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds context about mode-specific behavior (e.g., 'team plans only' for team mode) and output format token savings. It does not mention rate limits or performance characteristics, but overall adds useful 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?

The description is concise, with two focused paragraphs: one for modes and one for output formats. It front-loads the core purpose: 'Search workspace memory and knowledge.' Every sentence adds value without redundancy.

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

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

Given the complexity (11 parameters, many modes) and lack of output schema, the description covers modes and output formats adequately but misses details on pagination, default behavior for 'include_memory', and how 'exact_match_boost' works. Schema fills some gaps, but description could be more comprehensive.

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

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

The input schema has 100% description coverage, providing baseline. The tool description adds meaning beyond schema by explaining modes (e.g., 'meaning-based', 'exact match') and output format savings (e.g., '80% token savings'). This enriches the semantic understanding of 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 tool searches workspace memory and knowledge. It lists various modes and output formats, which adds specificity. However, it does not explicitly differentiate from sibling tools like 'tool_search' or memory-specific 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 guidance on when to use each mode (e.g., 'auto recommended', 'keyword exact match'), which is helpful for mode selection. However, it lacks explicit guidance on when to use this search tool versus other available tools, such as memory retrieval or batch 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?

The description contradicts annotations: readOnlyHint=true but the tool includes write actions (capture, capture_lesson, remember, etc.), and destructiveHint=false despite delete_lesson and other destructive actions. The description itself is detailed about behaviors, but the contradiction with annotations is severe, reducing 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 very long and front-loaded with key distinctions, but it could be more concise by separating action lists into structured bullet points. It is moderately well-structured but verbose.

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 52 parameters and many actions, the description covers usage context well (when to use recall, ground, etc.) and explains key concepts. However, it lacks details on return values and error handling, which would be beneficial for such a complex 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?

Schema coverage is 100%, so baseline is 3. The description adds context for some parameters (e.g., user_message for ground) but mostly lists actions without deeper parameter details. It does not substantially enhance understanding 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 that this tool is for 'Session and memory management' and explicitly distinguishes it from 'search' tool for codebase/file search. It lists many specific actions, making the purpose very clear.

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

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

The description provides explicit guidance on when to use actions like 'recall' for past sessions and 'capture_lesson' for mistakes. It warns against writing lessons to local files and explains how to use 'ground' for one-shot bundles. This is thorough and actionable.

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 says 'capture and store' implying persistence, but lacks details on side effects (e.g., overwriting, limits, retrieval). Annotations are minimal (readOnlyHint=false, destructiveHint=false) and the description adds little beyond the basic write operation.

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

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

The description is very concise at two sentences, with the core action front-loaded. It avoids unnecessary words, but could be slightly more structured (e.g., separating purpose from usage guidance).

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 (10 parameters, nested objects, no output schema) and lack of annotations, the description is insufficient. It does not explain what 'capture' entails for retrieval, how required fields work, or any behavioral nuances. The agent lacks guidance on how the stored context can be accessed later.

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% coverage with descriptions for all parameters. The tool description does not add new information beyond the schema, but it provides context on event_type (by listing examples like 'decisions, insights, preferences') which aligns with the enum values.

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

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

The description clearly states the tool captures and stores context from conversations. The title reinforces this. It distinguishes from siblings like memory_create_doc and session_remember by focusing on persisting general context, though it could be more specific about 'context' meaning conversation 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 examples of when to use it (persist decisions, insights, preferences, or important information) but does not explicitly state when not to use it or how it compares to alternatives like session_capture_lesson or memory_create_doc.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, so the description correctly implies a write operation. It adds that the lesson is tagged 'lesson' and stored for future retrieval, which is helpful. However, it does not disclose permission requirements or confirm 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 concise and well-structured with bullet points. It front-loads the purpose, followed by usage guidance and examples, with no extraneous 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 capture tool, the description covers purpose, triggers, and storage behavior. However, it lacks output specification (no output schema) and does not mention what the tool returns, leaving some gaps in completeness.

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

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

The schema covers all parameters with descriptions (100% coverage). The description does not add additional meaning beyond the schema; thus 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 that the tool captures a lesson from a mistake or correction, with specific trigger examples. However, it does not explicitly differentiate from sibling tools like session_capture or session_remember, which may have overlapping purpose.

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 guidance on when to use this tool (user corrections, frustration, errors) but does not mention when not to use it or suggest alternative tools 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?

Annotations already indicate readOnlyHint=false (write operation) and destructiveHint=false (non-destructive). The description adds minimal context beyond 'store something in memory', without disclosing whether it overwrites or appends, or any side effects. For a write tool, more behavioral detail is needed given annotation coverage.

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

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

Description is extremely concise: one sentence plus two examples. Every sentence adds value by explaining the tool's purpose and usage pattern. No unnecessary words or repetition.

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

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

No output schema is provided, yet the description does not mention what the tool returns after storing (e.g., confirmation, memory ID). For a tool that writes data, this is a significant gap. Parameter descriptions are complete, but the overall behavioral outcome is unclear.

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 parameters are well-documented in the schema. The description adds natural language guidance for the 'content' parameter but does not elaborate on other parameters like 'importance', 'await_indexing', etc. Baseline of 3 is appropriate as 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?

Description states the tool stores something in memory using natural language, with examples. It clearly identifies the verb 'store' and resource 'memory', distinguishing it from siblings like 'memory_create_doc' by emphasizing quick, natural language input. However, no explicit sibling differentiation is provided.

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?

Description implies usage when you want to quickly store something using natural language (e.g., 'Quick way to store something in memory'). It provides examples but no explicit when-not-to-use or alternative tools. Lacks exclusions or guidance on when to choose this over siblings like 'memory_create_doc' or 'reminder'.

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 annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description includes write actions (create, update, delete, import). This is a direct contradiction, causing confusion about the tool's behavior.

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

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

The description is well-structured with a brief intro and bullet-pointed actions. It is of appropriate length and front-loads key information, though it could be slightly more concise.

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 (29 parameters, multiple actions), the description covers the tool's capabilities adequately. However, the annotation contradiction undermines completeness, and lack of output schema information is acceptable. Score penalized due to contradiction.

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 baseline is 3. The description adds some context for actions (e.g., supersede archives skills), but does not provide additional meaning for individual parameters beyond what's in the schema.

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

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

The description clearly states the tool manages and executes reusable skills, and lists all specific actions (list, get, create, update, run, etc.). It distinguishes from sibling tools by specifying its focus on skills.

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 skills are portable and gives a specific note about 'supersede' to retire stale skills. However, it does not explicitly state when to use this tool versus alternatives, but the purpose is clear enough.

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

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

Annotations already provide safety hints (readOnly=true, idempotent=true). The description adds value by revealing it can find hidden operations and that execute_operation is for deferred capabilities, adding behavioral context beyond annotations.

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

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

The description is a single, well-structured sentence that is front-loaded with the primary action and includes follow-up guidance. No wasted words; every phrase 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?

While the description covers the basic purpose and post-search actions, it lacks specificity about how the search works (e.g., criteria, results format). With no output schema, more detail on what the search returns 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?

No parameters are defined in the input schema, so schema description coverage is trivially 100%. The description does not need to explain parameters; baseline for 0 params is 4, and no additional info is required.

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 tool searches for tools and hidden operations, with a specific verb ('Search') and resource ('available tools and hidden operations'). It also outlines follow-up actions, distinguishing it from sibling tools like 'search' or 'execute_operation'.

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

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

The description implies usage by mentioning 'then call direct tools or use execute_operation', but it does not explicitly state when to choose this tool over alternatives like the generic 'search' or 'execute_operation' tools. Guidance on context is minimal.

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

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

Annotations declare readOnlyHint: true and destructiveHint: false, but the description includes many mutating actions (create_issue, update_issue, merge_pull, etc.), creating a direct contradiction. Beyond that, the description does not disclose any behavioral traits such as authentication needs, rate limits, or side effects.

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 overly long due to an exhaustive list of actions, which could be condensed or grouped. It starts with a clear purpose statement, but the bulk is a repetitive list that adds little value. It is not concise.

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

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

For a tool with 24 parameters and many sub-actions, the description is severely lacking. It does not explain what each action does, when to use them, or what the return values are. The annotations contradict, and no output schema exists. The description is inadequate for effective tool selection.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any additional meaning to parameters beyond what the schema already provides; it merely lists action names. The schema's parameter descriptions are minimal but present.

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 'Git version control and remote repo operations' and lists specific actions, clearly indicating the tool's broad scope. It distinguishes from sibling tools by focusing on VCS operations, though it doesn't explicitly differentiate from potentially overlapping tools like 'execute_operation'.

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 simply lists actions without any context on prerequisites, limitations, or when to prefer other tools. No 'when not to use' or alternative tool references are provided.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, but the description includes create, delete, and bootstrap actions, which are clearly not read-only. This is an annotation contradiction. The description does not address side effects or mutation 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 long run-on list of actions with minor qualifiers. It lacks structured breakdown (e.g., grouping by read vs write) and is not front-loaded with essential info. Each sentence earns its place but poorly organized.

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 18 parameters and multiple actions, the description does not explain how parameters relate to actions, nor does it describe return values (no output schema). It fails to provide enough context for correct invocation, especially for write actions.

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