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

With no annotations provided, the description carries the full behavioral burden. It usefully discloses that notes persist locally as JSON until resolved and that `read` returns only open notes, but says nothing about whether resolve deletes or merely flags notes, error handling, or concurrency 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 opening line is front-loaded and the Args block is compact, with no rambling. The trailing "Returns: JSON result." is filler since an output schema already exists, but it costs little.

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 multi-action tool with five params at 0% schema coverage and no annotations, the description covers the actions, parameter roles, and persistence model adequately. Return-value detail is correctly omitted because an output schema exists.

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

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

Schema description coverage is 0%, so the prose must document all five parameters, and it does: it defines `to` as a recipient agent/context name, gives `from_agent`'s default, and marks `message` and `note_id` as conditionally required per action. This meaningfully compensates for the empty 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 names a specific resource (handoff notes between agents) and enumerates the three distinct operations (write, read, resolve). No sibling tool overlaps with this capability, so an agent can identify it immediately from the name-plus-description pair.

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?

Each action value is glossed with its purpose: write to leave a note, read to fetch open notes addressed to `to`, resolve to close a note by id. This is clear per-action guidance, but there is no explicit when-not-to-use or routing to an alternative tool.

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

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

No annotations are provided, so the description carries the burden, and it does disclose the response shape ('concise reference', JSON {ok, help}) and that it is a documentation-style lookup with no stated side effects. It adds no context about auth requirements, rate limits, or caching, so it is adequate but thin for a zero-annotation tool.

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

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

The core purpose is front-loaded in the first sentence and the text is short. The trailing 'Returns: JSON: {ok, help}' block is largely redundant given that an output schema already exists, costing a little conciseness.

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

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

For a simple, zero-parameter help tool with an output schema present, the description covers purpose, audience, and the nature of the response. The only gap is not positioning it against the overlapping list_capabilities/blackbox_status siblings.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey; the baseline for a parameterless tool applies. Nothing in the description misrepresents the empty argument object.

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

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

The description states a specific verb and resource: 'Explain BlackBox capabilities and how an agent should use them', plus the audience (MCP clients including Zed). However, it does not differentiate itself from similar siblings such as list_capabilities or blackbox_status, which an agent could plausibly confuse with a self-description 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?

It implies the trigger ('understand what BlackBox can do without external documentation'), which is usable guidance, but never states when to prefer this over list_capabilities or blackbox_status, nor any exclusion conditions. Usage is inferable but not explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that secrets are not exposed and enumerates the returned data, but it never explicitly states this is a read-only, non-destructive, idempotent operation, nor mentions permissions or rate limits.

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 overview sentence is front-loaded, the bulleted contents are scannable, and there is no filler. The only minor redundancy is the inline return shape, but it is brief.

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 an output schema present, return values need not be restated, yet the description still helpfully lists what the status payload contains and notes the secrets exclusion. It is complete for a zero-parameter status tool, with only the when-to-use dimension left uncovered.

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

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

The tool takes zero parameters, so the baseline of 4 applies. There is no parameter semantics to add beyond the empty schema.

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

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

States a specific verb and resource ('Return a concise overview of BlackBox status') and enumerates the exact contents of that overview, so the agent knows what it gets. It does not name or differentiate from siblings like list_providers or list_assistants, so it stops short of a 5.

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

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

There is no explicit guidance on when to call this versus the many sibling list/get tools (list_providers, list_assistants, get_memory, etc.). The overview framing implies a broad health-check use, but no alternatives or exclusions are stated.

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

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

With no annotations, the description carries the full behavioral burden. 'when possible' hints that cancellation can fail, but it does not disclose permission requirements, whether cancellation is idempotent, what happens to a running task mid-execution, or whether it is reversible.

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 core sentence is short and front-loaded, but the 'Args:/Returns: JSON result' boilerplate is filler — the return value is already covered by the output schema, and the Args block duplicates the parameter name.

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?

An output schema exists so return format needn't be explained, but for a mutation tool with no annotations, zero parameter documentation, and no guidance about eligibility or error conditions, the description is too thin to let an agent invoke it confidently.

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

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

Schema description coverage is 0%, so the description must compensate, but 'Task id to cancel' only restates the parameter name without adding format, source, or lookup guidance (e.g., where to get a task id). Minimal 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?

States a specific verb (Cancel) and resource (task), and scopes it to 'queued or running' tasks, which tells the agent which task states are eligible. It does not distinguish itself from siblings like get_task, list_tasks, or review_task, so sibling differentiation is missing.

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?

'when possible' is the only usage hint and is too vague to guide selection — it doesn't say when cancellation is impossible, what conditions are required, or what alternative to use if it fails. No alternatives among the many task-related siblings are named.

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

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

With no annotations, the description carries the full disclosure burden for what is clearly a destructive bulk operation. It states nothing about whether deletion is reversible, whether entries across agents/workspaces are affected, what permissions are required, or whether the operation is scoped to the caller's memory. Only the parameter defaults and a return shape are given.

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?

Purpose is front-loaded in the first sentence, followed by compact Args and Returns blocks. The structure is slightly boilerplate but nothing is wasted and no sentence is filler.

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 presence of an output schema means the Returns block is partly redundant. However, for a destructive multi-parameter tool backed by zero annotations, the description does not address irreversibility, scope of effect, or interaction between the two limits, leaving it only marginally complete.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: it explains both parameters' meaning and defaults ('max_age_days: Maximum age in days (default 90)', 'max_entries: Maximum number of entries to keep (default 10000)'). It does not explain their interaction (OR vs AND, precedence when both are set), which is a residual gap.

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?

States a specific verb ('clean up') and resource ('old memory entries') with the governing rule ('based on retention policy'). It reads as a bulk retention-pruning operation, distinguishable from delete_memory and save_memory, though it never names or contrasts those siblings explicitly.

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 when-to-use guidance, no mention of prerequisites, and no reference to alternatives like delete_memory for targeted removal. The phrase 'based on retention policy' implies periodic bulk maintenance but leaves the agent to infer the trigger conditions.

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

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

No annotations are supplied, so the description carries the full burden, and it partially meets it: it explains what each approval flag gates (command execution, file writes, destructive operations), which is genuine behavioral context. However, for a mutation tool it omits persistence scope, whether omitted fields reset to defaults, permission requirements, and reversibility of the change.

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?

Front-loaded one-line purpose followed by a compact arg-by-arg list and a short returns note. No filler. The Returns section is somewhat redundant given an output schema exists, but it costs little.

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 seven-parameter mutation tool with no annotations, the definition should clarify persistence scope, default-handling on omission, and whether changes affect in-flight tasks. It covers parameter meaning and the response shape (also available via output schema) but leaves the operational consequences of the mutation unexplained.

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

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

Schema description coverage is 0%, so the description must compensate, and it does enumerate all seven parameters with a one-line gloss each. But most glosses merely restate the schema title (e.g. 'max_concurrent: Maximum concurrent tasks'), adding little meaning; only 'default_timeout: Default timeout in seconds' supplies information the schema lacks. Adequate but thin.

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?

States a specific verb+resource: configure the task manager's safety limits, and the body enumerates the exact safety dimensions (concurrency, timeout, delegation depth, approval gates). This clearly distinguishes it from task-execution siblings like delegate_task or get_task. It stops short of 5 because it never names a sibling alternative.

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

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

There is no when-to-use, when-not-to-use, or prerequisite guidance. Nothing tells the agent whether this is per-session, global, or persistent, or when it should be called instead of request_task_approval or resolve_approval, which also touch the approval machinery.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that provider and model are mutable later without affecting identity, name, or system prompt, and flags the provider-existence precondition. However, it says nothing about permissions required, error behavior, or side effects of the write, and 'Returns: JSON result' is only rescued by the output schema.

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?

Uses a front-loaded purpose sentence followed by structured Args/Returns sections. Every argument line earns its place, including the non-obvious provider/model mutability note. Slightly verbose but well organized and easy to scan.

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 an 11-parameter creation tool with a rich output schema and no annotations, the description covers purpose, all parameters, mutability, and one key precondition. It omits auth requirements and failure modes, but the presence of an output schema removes the need to explain returns.

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

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

Schema description coverage is 0%, yet the description documents all 11 parameters with types, ranges (temperature 0.0-2.0), defaults (assistant_id slugged from name), and JSON-format examples for capabilities/permissions/metadata. This fully compensates for the bare schema and adds meaning well beyond it.

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?

States a specific verb and resource ('Create a new assistant profile'), which cleanly separates it from update_assistant, delete_assistant, and create_provider. It does not explicitly name a sibling or explain the boundary, but the intent 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?

Usage is implied rather than stated. The only routing hint is the precondition that the provider 'must already exist via create_provider', which tells the agent a prerequisite step exists. There is no explicit guidance on when to choose this over alternatives or what conditions preclude creating an assistant.

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

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

With no annotations, the description carries the full burden and does disclose a genuinely non-obvious trait: secrets are not persisted, and api_key_env holds a variable NAME resolved at request time. It also states uniqueness of the name. It omits permission/auth requirements, duplicate-name behavior, and error semantics, but the secret-handling disclosure is high 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?

Front-loads the purpose, then the important secret-handling caveat, then a clean Args block. Well organized, but the 'Returns: JSON result' line is content-free filler, especially given an output schema exists.

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 5-parameter, zero-schema-coverage, annotation-free creation tool, this is close to complete: the secret model, parameter formats, and enum values are all supplied, and the output schema covers return values. Only failure modes (duplicate name, invalid type) and auth requirements are unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate and it does: it documents all five parameters, gives the three valid 'type' values (stub, openai_compatible, ollama) that the schema leaves as an undescribed string, specifies name casing/allowed separators, and gives examples for api_key_env and options. This materially exceeds what the schema conveys.

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?

States a specific verb and resource ('Create a provider configuration'), which cleanly separates it from the sibling CRUD operations update_provider, delete_provider, and list_providers by verb alone. It does not explicitly name an alternative, but the operation 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?

No when-to-use guidance, no prerequisites, and no routing advice relative to update_provider or the other provider tools. The secrets/environment-variable note is useful setup context but is not usage guidance for choosing this tool over another.

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

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

No annotations are provided, so the description carries the full burden. It doesn't disclose whether the call blocks, whether it spawns retrievable child tasks (list_tasks/get_task), auth requirements, rate limits, or what 'depth' recursion implies. The Args list is largely a restatement of parameter names with thin 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?

Front-loaded purpose followed by compact Args and Returns blocks. Reasonably sized with little padding, though the Args lines are terse to the point of adding minimal 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?

This is a multi-param task-orchestration tool with no annotations and numerous closely related siblings, so the description should do more. It omits alternative-tool routing, recursion/depth behavior, and blocking/async semantics, leaving significant gaps despite an output schema covering 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 0%, so the description must compensate. It partially does: it clarifies that assistant_ids is a JSON list and context is a JSON object even though the schema types them as plain strings, and it explains timeout as per-task and depth as delegation depth. However, formats, defaults, and the recursion/depth semantics remain underspecified for a 5-param tool.

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?

States a specific verb (delegate) and resource (task) with a differentiating scope: 'multiple assistants for competing analyses.' An agent can infer this differs from single-delegation or parallel execution siblings, but the description never names delegate_task or parallel_task to make the contrast 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 when-to-use guidance is given. It does not say when to prefer this over delegate_task, parallel_task, pipeline_task, or review_task, nor does it state prerequisites or expected call context. The 'competing analyses' phrase implies intent but stops short of routing 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?

With no annotations, the description carries the full behavioral burden and does well: it discloses that execution is asynchronous, that the caller must poll get_task(), and that the immediate result is only a queued task_id. It omits permission/auth requirements, failure semantics, and interaction with cancel_task, but the core behavioral model is unusually clear.

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?

Front-loads the core action and the async polling requirement in the first two sentences, then uses compact Args/Returns blocks. Efficient overall, with minor redundancy in restating the return payload that an output schema already covers.

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

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

For a 6-parameter, annotation-free tool, the description supplies the async model, parameter meanings, defaults, and expected return keys. Because an output schema exists the Returns block is redundant but harmless; the remaining gap is the absence of guidance distinguishing this tool from its task-variant siblings.

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

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

Schema description coverage is 0%, so the description is the only documentation and it covers all six parameters, adding meaning beyond the schema types: timeout defaults to the global default, depth is flagged as advanced with a recommended value, and mode enumerates five delegation modes. It is a solid compensation for the coverage gap, though 'context' type (schema says string, text says JSON object) could be clarified further.

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?

States a specific verb and resource ('Delegate a task to a configured assistant and return a structured task id') and immediately characterizes the operation as asynchronous. An agent can distinguish this from siblings like list_tasks or cancel_task without opening any schema.

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?

Gives clear operational guidance for the async lifecycle ('poll get_task() for status') and notes 'leave 0 for top-level tasks' for depth. However, it never explains when to choose this tool over the look-alike siblings parallel_task, review_task, debate_task, or pipeline_task, even though the 'mode' argument lists the same concepts (delegate, parallel, review, debate, pipeline) — the routing decision is left ambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes an assistant and returns JSON, but does not disclose whether deletion is permanent, what happens to related tasks or memory, required permissions, or any other behavioral trait beyond the tool name itself.

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

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

The description is short and front-loads the purpose. The Args section is clear. The 'Returns: JSON result' line is somewhat redundant because an output schema exists, but it does not significantly detract from an otherwise efficient structure.

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

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

For a destructive delete operation with no annotations and an output schema, the description is incomplete. It fails to warn about irreversibility, permissions, or side effects, leaving the agent without enough context to invoke the tool safely. The output schema covers return values, but behavioral context is missing.

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

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

Schema description coverage is 0%, so the description must compensate. It does provide a minimal label for the single parameter ('assistant_id: Assistant id to delete'), which is enough to identify it, but adds no format, source, or lookup guidance. This meets the minimum for a simple ID parameter but does not go beyond it.

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

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

The description states a specific verb and resource: 'Delete an assistant profile.' This distinguishes it from sibling deletion tools like delete_provider and delete_memory, though it does not explicitly differentiate it from adjacent assistant tools such as update_assistant or disable_assistant.

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. It does not mention prerequisites, warnings about irreversibility, or the relationship to enable_assistant/disable_assistant. Usage is only implied by the verb '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 are provided, so the description carries the full behavioral burden. It says 'Delete' and 'Returns: JSON result,' but does not disclose destructive/irreversible implications, permission requirements, or side effects. 'Returns: JSON result' is also redundant because an output schema exists.

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

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

The description is short and front-loaded with the operation and parameter. The Args/Returns structure is easy to scan, though the 'Returns: JSON result' line is unnecessary given the output schema.

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

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

For a destructive single-parameter operation with no annotations and an output schema, the description covers only the bare invocation. It lacks the safety and behavioral context an agent needs before calling a delete 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 description coverage is 0%, so the description must compensate for the undocumented entry_id parameter. It only restates 'Memory entry id' in tautological fashion, adding no format, sourcing, or validation details beyond the schema's parameter name.

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

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

The description gives a specific verb and resource: 'Delete a memory entry by id.' This clearly distinguishes deletion from sibling memory tools such as save_memory, get_memory, search_memory, and cleanup_memory. It does not explicitly differentiate from cleanup_memory, but the core purpose is 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 states what the tool does but gives no guidance on when to use it versus alternatives like cleanup_memory. It also omits prerequisites such as whether deletion is permanent or what happens if the entry_id does not exist.

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

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

With no annotations present, the description carries the full behavioral burden, yet it discloses nothing beyond the destructive verb. It does not state whether deletion is irreversible, whether it cascades to dependent assistants, or what permissions are required.

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 one-sentence purpose is front-loaded and waste-free, but the 'Args:' and 'Returns: JSON result.' boilerplate adds little, especially since an output schema already exists and makes the Returns line redundant.

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

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

For a destructive mutation tool with zero annotations, the definition is too thin: it omits reversibility, permission requirements, and side effects on related entities. The existence of an output schema only excuses the missing return-value explanation, not the missing behavioral context.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that the 'name' parameter is a provider id (beyond the schema's bare 'Name' string), but gives no format, example, or lookup guidance.

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

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

The description states a specific verb and resource ('Delete a provider configuration'), so the operation is unambiguous. However, it offers no differentiation from siblings such as delete_assistant or delete_memory, which share the same verb pattern.

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

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

No guidance on when to use this tool versus alternatives like update_provider, and no prerequisites or warnings about the consequences of deletion are given. The agent must infer everything from the verb alone.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one meaningful trait — the assistant stops accepting delegated tasks — but omits reversibility, permission requirements, and the fate of currently running tasks, all of which matter for a state-changing tool.

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

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

The core sentence is front-loaded and tight, but the boilerplate 'Args:' and 'Returns: JSON result' sections add little, especially since an output schema already exists to describe the return 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?

For a mutation tool with no annotations and an undocumented parameter, the description is too thin: no side effects, no reversibility, no permissions. The output schema covers the return value, so that gap is less important, but the behavioral gaps remain.

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

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

Schema description coverage is 0%, and the description only restates the parameter as 'Assistant id', adding no format, source, or lookup guidance (e.g., from find_assistants or list_assistants). It does not compensate for the coverage gap.

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?

States a specific verb (disable) on a specific resource (assistant) and adds the operational consequence that it will no longer accept delegated tasks, which distinguishes it behaviorally from the sibling delete_assistant. It does not explicitly contrast with enable_assistant, but the intent 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?

No guidance on when to disable versus delete, whether this is reversible, or what happens to in-flight delegated tasks. The consequence clause hints at usage but never states context or alternatives.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose the state change's effect (assistant becomes able to receive delegated tasks), which is useful, but it says nothing about idempotency, permissions, reversibility, or side effects on existing tasks.

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 first sentence is short and front-loaded, but the boilerplate 'Args:' / 'Returns: JSON result.' block is pure noise — the arg doc is tautological and the return note is redundant given an output schema exists.

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

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

For a simple one-parameter mutation with an output schema, the description is minimally adequate: the effect is stated and the return format need not be explained. However, with zero annotation coverage it leaves permission, idempotency, and failure behavior unaddressed.

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

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

Schema coverage is 0% and the description's only parameter note is 'assistant_id: Assistant id.' — a tautological restatement of the property name that adds no meaning (format, where to obtain the id, or optionality). It does not compensate for the coverage gap.

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 gives a specific verb (Enable) and resource (assistant) plus the functional consequence ('so it can receive delegated tasks'), which cleanly distinguishes it from disable_assistant. It stops short of naming siblings explicitly, but the action 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?

Usage is only implied via the consequence clause — the agent can infer this is the counterpart to disable_assistant. There is no explicit when-to-use, no precondition (assistant must already exist/be disabled), and no stated 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?

No annotations are provided, so the description carries the full burden. It does disclose real behavioral traits: disabled assistants are excluded by default unless include_disabled is set, and matching defaults to all-of rather than any-of. It says nothing about permissions, rate limits, or result ordering, so disclosure is partial for an unannotated tool.

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

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

Front-loaded with the purpose, then an Args/Returns breakdown that is easy to scan. Every sentence is relevant. Minor redundancy in the two-sentence opening, but nothing is wasted.

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?

An output schema exists, so the description need not explain return values, and it correctly defers with 'Returns: JSON result.' Given the tool is a read-only discovery query with only three simple parameters, the description covers purpose, matching semantics, and default filtering adequately. Permission and result-shape behavior remain unstated but are low-risk here.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: capabilities is given a format and example ("JSON list of required capability terms, e.g. ['swift', 'ios']"), any_of is explained as match-any-vs-all with its default, and include_disabled is explained. This adds substantial meaning beyond the bare schema. It does not resolve the type mismatch between the schema's string type and the 'JSON list' description.

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?

States a specific verb and resource ('Find assistants') plus the discriminating filter ('whose capabilities match the given requirements'). The rationale sentence clarifies it is capability-based discovery distinct from id-based lookup, which separates it from the sibling list_assistants. It stops short of naming list_assistants explicitly, so sibling differentiation is implied rather than stated.

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 line 'so a lead agent does not need to know every assistant's id' gives an implied when-to-use (capability-driven discovery rather than id lookup). However, there is no explicit when-not guidance and no named alternative such as list_assistants for enumerating everything. Usage is inferable but not spelled out.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read ('Return the complete configuration') but says nothing about authorization, what happens if the assistant_id is unknown, or the depth of the returned configuration. The only disclosure is that the result is a single complete configuration.

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 one-line purpose is front-loaded and efficient, but the Args/Returns boilerplate adds little: the Args line is a tautology and the Returns line ('JSON result') is redundant given an output schema exists. Short overall, but not every line 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?

With an output schema present, the description need not enumerate return fields, and for a single-parameter getter the scope is small. Still, it omits error behavior and any hint of what 'complete configuration' contains, which is the main thing an agent would want to know before calling.

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

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

Schema description coverage is 0% and there is one required parameter. The description's 'Args: assistant_id: Assistant id.' merely restates the property name and type with no added meaning (no format, no source, no constraints), leaving the parameter effectively undocumented.

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?

States a clear verb and resource: 'Return the complete configuration for one assistant.' That distinguishes it from list_assistants and find_assistants, which return collections. It stops short of explicitly naming a sibling or contrasting scopes, so it is clear but not sibling-routing.

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 indication of when to use this versus find_assistants, list_assistants, or update_assistant. No prerequisites, no note about whether the id comes from a listing call, and no exclusions. The agent must infer usage entirely.

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

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

No annotations are provided, so the description carries the full burden. It only describes the return shape, which is already covered by the output schema, and says nothing about side effects, required permissions, or error handling beyond 'not found'.

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?

Front-loads the purpose in one clear sentence and uses standard Args/Returns sections. It is appropriately sized, though the return block is somewhat redundant with the output schema.

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

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

For a simple one-parameter lookup with an output schema present, the description covers the essential purpose and parameter meaning. It misses usage context and behavioral safety details, but those are less critical for a simple retrieval 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 description coverage is 0%, so the description must compensate. It adds that the id refers to a memory entry, which is useful domain context, but does not describe the id format or how to obtain it.

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?

States a specific verb ('Retrieve') and resource ('a memory entry') scoped by id. This implicitly distinguishes it from sibling search_memory, but no alternative is named explicitly.

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 search_memory, list_memory_categories, or other memory siblings. The description only says what it does, not when to choose 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?

No annotations are provided, so the description carries the full burden. It discloses that a result is returned and that the 'current' state is fetched (implying asynchronous polling rather than blocking), but says nothing about whether the call blocks, how pending vs completed tasks are represented, or error/auth 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 core purpose is front-loaded in one sentence, with Args/Returns sections kept short. The 'Returns: JSON result.' line is boilerplate that adds little given an output schema exists, but nothing is padded.

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?

An output schema exists, so return shape need not be described. For a single-parameter getter with no annotations, the definition is minimally adequate but omits the async/polling semantics and error behavior an agent needs to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It does add real value by establishing the provenance of task_id ('from delegate_task'), but gives no format, validity, or error semantics for an invalid id.

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?

States a specific verb and resource ('Return the current state/result of a delegated task'), which clearly distinguishes it from the bulk list_tasks and the mutating cancel_task. It does not explicitly name the sibling it complements, but the singular 'task' scope makes the distinction inferable.

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 ties the input to delegate_task ('Task id from delegate_task'), implying this is used to poll a previously delegated job, but it never states when to use this versus list_tasks or review_task, nor any when-not condition.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the return shape and the include_disabled filter, and 'List' implies read-only behavior, but it omits permissions, pagination, and rate-limit 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 and front-loaded, with clear Args and Returns sections. Every line earns its place, and the optional parameter is easy to find.

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 list operation with one optional parameter and an output schema, the description is nearly complete. It covers the filter and return envelope, but lacks any usage context relative to sibling tools.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter. It does so by explaining that include_disabled also includes disabled assistants and defaults to False, which is sufficient for this one optional boolean.

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?

States a specific verb and resource: listing configured assistants and their relevant configuration. It clearly conveys what the tool does, but does not distinguish itself from siblings like find_assistants or list_capabilities.

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 guidance on when to use this tool versus alternatives such as find_assistants, get_assistant, or list_capabilities. Usage is only implied by the tool's name and verb.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully states that only enabled assistants are covered and that the response shape is {"ok": true, "capabilities": [...]}, but it does not discuss permissions, side effects, or whether disabled assistants are included or excluded beyond the word 'enabled'.

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

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

The description is short and front-loaded with the core action. The return-value block is slightly redundant because an output schema exists, but it is still compact and does not waste much space.

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 no-parameter list tool, the description gives the action, scope, intended use, and return shape. It is nearly complete, though it could briefly mention related alternatives or when not to use this tool in favor of sibling discovery tools.

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

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

The tool has zero parameters, so there are no parameter semantics to clarify. The empty schema is fully described by its structure, and the baseline for a no-parameter tool 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 first sentence gives a specific verb and resource: 'List all capabilities available across enabled assistants.' It clearly scopes the result to enabled assistants and distinguishes the capability resource from sibling resources such as assistants, providers, and tasks.

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 a contextual use case: a lead agent can discover capability terms in order to pick an appropriate assistant. However, it does not say when to use this tool versus alternatives like find_assistants or list_assistants, and it gives no exclusion criteria.

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

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

With no annotations present, the description carries the full behavioral burden. 'List' strongly implies a read-only, non-destructive operation and the return shape is stated, but there is no information about permissions, whether categories can be empty, or pagination 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 core purpose is front-loaded in a single sentence, and the Args/Returns block is short. The boilerplate section headers are slightly heavier than needed for a one-parameter tool, but nothing is padded.

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

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

For a simple one-parameter listing tool with an output schema already present, the description covers purpose, the optional scope, and the return envelope. It does not explain where categories originate, which is a minor omission rather than a blocker.

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

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

Schema description coverage is 0%, so the schema only shows 'project' as a string with a default of empty, adding no meaning. The description compensates minimally by labeling it an optional project filter, which clarifies optionality but nothing about matching semantics or format.

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?

States a specific verb and resource — 'List all memory categories in use' — which is unambiguous. It is distinguishable from siblings like save_memory, get_memory, search_memory, and cleanup_memory by naming the category resource, though it never explicitly contrasts itself with them.

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?

'optionally scoped to a project' implies the filtering scenario, but there is no guidance on when an agent should call this versus search_memory or get_memory, nor any prerequisites. Usage is inferable only from the tool name and purpose.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only restates the return shape, which the output schema already provides, and says nothing about read-only safety, scope (whose approvals), permissions, or pagination/volume limits.

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 lines, front-loaded with the action, with no filler prose. The 'Returns' block is redundant against the existing output schema, which is the only real waste.

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?

An output schema exists, so return values need not be explained, and the low-complexity read operation needs little more. However, with zero annotation coverage, the description leaves the scope of 'pending approvals' (user vs. workspace) and result volume unspecified.

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

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

The tool takes zero parameters, so the baseline is 4. There is no parameter semantics to add or omit, and the description does not misrepresent the (empty) input contract.

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?

States a specific verb and resource ('List all pending approval requests'), which is unambiguous and distinguishable from siblings like resolve_approval and request_task_approval. It stops short of explicitly contrasting with those siblings, so it does not reach a 5.

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

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

No when-to-use guidance, no prerequisites, and no pointer to the natural follow-up tool (resolve_approval) that consumes these approvals. The agent must infer usage entirely 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?

With no annotations, the description carries the behavioral burden and does so well for the sensitive-data concern: it states that API keys are never returned and only the environment variable name is shown. It does not mention authentication or side-effect safety explicitly, but 'List' implies read-only 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 front-loaded and efficient: purpose first, then the key safety constraint about API keys, then return shape. The Returns block is somewhat redundant because an output schema exists, but it is brief and does not bloat the definition.

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 low complexity and zero input parameters, the description is nearly complete: it explains the resource, the safe public scope, the API-key behavior, and the response envelope. It omits auth/permission requirements, but with an output schema present, return details are sufficiently covered.

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

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

The tool takes zero parameters, so there are no parameter semantics to add. The baseline score for a parameterless tool is 4, and the description does not need to compensate further.

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

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

The description uses a specific verb and resource: 'List configured providers and their safe, public configuration.' It clearly distinguishes this read operation from sibling mutation tools like create_provider, update_provider, and delete_provider.

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 purpose implies when to use it, but the description does not explicitly state when to choose list_providers over alternatives or mention sibling tools such as get_assistant or update_provider. It is usable, but guidance is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only states 'Returns: JSON result.' It does not disclose that this is a non-mutating read, whether results are paginated or ordered, or what the caller needs (e.g., no auth prerequisites stated). For a tool with zero annotation coverage this is a substantial gap.

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

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

Front-loaded purpose sentence followed by tightly grouped Args and Returns blocks; no filler. The docstring-style formatting is slightly mechanical but every line carries 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?

An output schema exists, so return values need not be explained, and all three parameters are documented. What's missing is behavioral context an agent needs for correct invocation: ordering/pagination of results and how this list relates to the sibling task tools. Adequate but incomplete.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it enumerates the valid status values (queued, running, completed, failed, cancelled), explains assistant_id as a filter, and gives limit's meaning and default. This is materially more than the bare schema provides, though enum values are documentation rather than a formal enum constraint.

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?

States a specific verb (list) and resource (delegated tasks) with a scope qualifier ('recent or active'). It is clear what the tool does, but it does not differentiate itself from close siblings like get_task or list_pending_approvals, leaving the agent to infer the boundary.

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 versus get_task (single task), cancel_task, or list_pending_approvals. The 'recent or active' qualifier hints at scope but is never tied to an alternative or a when-not condition.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state what happens if one assistant fails, whether calls are truly concurrent, auth/rate-limit considerations, or side effects. The mention of 'depth: Current delegation depth' hints at recursion limits but is not explained as a safety constraint.

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 parallel-delegation purpose is front-loaded in the first sentence, followed by a compact Args/Returns block with no filler. The structure is mechanical but efficient, and nothing is wasted.

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?

An output schema exists, so the Returns line is largely redundant and the description need not detail return values. But with zero annotations and no usage guidance for a multi-target orchestration tool, the definition stops short of what an agent needs to pick it over its siblings.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it clarifies that assistant_ids is a JSON-encoded list and context a JSON-encoded object even though both are typed as plain strings, and gives units for timeout ('seconds'). 'depth' and 'task' are thinner restatements, but the type-encoding clarification is real 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?

States a specific verb (delegate) and resource (the same task to multiple assistants in parallel), which is clear enough to distinguish it from a single-target delegate_task. However, it never names or contrasts itself against close siblings like debate_task or pipeline_task, which also fan out to multiple assistants.

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 when-to-use guidance. Given siblings such as delegate_task, debate_task, and pipeline_task, the agent is left to infer that 'parallel' means independent identical tasks rather than a debate or staged pipeline. No prerequisites, exclusions, or alternatives are mentioned.

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

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

With no annotations, the description carries the full burden. It usefully discloses that timeout is per-task and that depth tracks delegation depth (a recursion hint), but says nothing about failure propagation mid-chain, blocking behavior, permissions, or what happens when depth is exceeded.

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?

Front-loads the one-line purpose before the Args/Returns blocks; each line is short and earns its place. The Returns line is somewhat redundant given an output schema exists, but the overall structure is clean.

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 multi-step orchestration tool, the definition covers inputs adequately but omits operational behavior an agent would need: error handling across the chain, whether execution is synchronous, and the recursive depth limit. The existing output schema offsets the need to describe 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 description coverage is 0%, so the description must compensate, and it does: it documents all five parameters, clarifies that assistant_ids is a JSON list in pipeline order and context is a JSON object (matching the string-typed schema fields), and explains timeout is per-task. It stops short of format examples or defaults for depth.

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?

States a specific verb and mechanism: 'Chain assistants where output from one becomes input to the next.' This implicitly distinguishes it from siblings like parallel_task and debate_task through the sequential hand-off wording, but it never names or contrasts those alternatives, leaving the agent to infer the boundary.

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 phrase 'output from one becomes input to the next' implies the chaining scenario, but there is no explicit when-to-use guidance, no conditions for choosing this over parallel_task, debate_task, or delegate_task, and no prerequisites or exclusions stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the tool scans a local directory and can persist a summary to local storage, which is helpful, but it does not clarify permissions, whether the project itself is modified, error behavior, or filesystem limits.

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

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

The description is front-loaded with the purpose and then structures parameter details cleanly. The Returns line is somewhat redundant because an output schema exists, but the overall size is appropriate and easy to parse.

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

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

The description covers the core purpose and all parameters, and an output schema exists so return values need not be detailed. However, with no annotations, it leaves behavioral gaps around permissions, side effects on the filesystem, and usage boundaries, making it only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all three parameters: path accepts absolute or relative paths, depth controls directory nesting with default 4, and save persists the summary with default True. This adds clear meaning beyond the bare schema.

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

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

The description states a specific verb and resource: scan a local project directory and record its structure. This is clearly distinct from all sibling tools, which focus on assistants, tasks, memory, and blackbox 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?

Usage is implied by the purpose ('scan a local project directory and record its structure for later reuse'), but there is no explicit when-to-use guidance, no prerequisites, and no alternatives named. Given that no sibling tool overlaps with project scanning, implied usage is adequate but not rich.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the return shape ({"ok": true, "approval": {...}}), which is useful, but omits critical traits: whether the call blocks awaiting a human decision, what happens if approval is denied or times out, and any permission requirements for a human-in-the-loop mutation.

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?

Front-loaded one-line purpose followed by compact Args/Returns sections; no wasted sentences. The structure is standard and scannable, though the Args/Returns formatting is verbose relative to the small surface.

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 2-parameter tool with no annotations, the description covers purpose, both parameters, and return shape, and an output schema exists. However, the blocking/async and failure semantics of an approval request are the central behavioral question here and go unaddressed, leaving a meaningful gap for an agent dealing with approval flows.

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

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

Schema description coverage is 0%, so the description must compensate and largely does: task_id is explained ('Task id to request approval for') and approval_type is enumerated as command/file_write/destructive/manual, filling a real gap since the schema declares no enum for it. Only minor gaps remain (default 'manual' behavior is not restated).

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

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

The description states a specific verb+resource: 'Request approval for a task', scoped to human-in-the-loop workflows. It is clearly distinguishable in intent from resolve_approval or list_pending_approvals, though it never names those siblings to reinforce the boundary.

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 parenthetical '(for human-in-the-loop workflows)' gives a context cue, but there is no explicit when-to-use vs. when-not-to-use guidance and no mention of the obvious alternatives (resolve_approval, list_pending_approvals). Usage is only implied by the phrasing.

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

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

No annotations are provided, so the description must disclose behavior. It states the mutation (approve/reject) and a return shape, but does not explain permissions, consequences of approving or rejecting, reversibility, or what happens to the underlying task or approval.

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?

Front-loaded first sentence states the action, followed by clear Args and Returns sections. No filler, every line serves a purpose.

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 two required parameters and an output schema, the description covers the operation and return contract. However, for a mutation tool with no annotations, it omits prerequisites and usage context that an agent would need to select it correctly.

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

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

Schema description coverage is 0%, so the description carries full parameter documentation. It explains both parameters clearly: approval_id identifies the approval, and approved is a boolean where True approves and False rejects.

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?

States a specific verb (approve/reject) and resource (pending approval request), so the action is clear. It does not distinguish itself from siblings like request_task_approval or list_pending_approvals, but the core purpose 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?

Mentions 'pending approval request' as the object, implying use after an approval is requested, but gives no explicit when-to-use guidance, alternatives, or prerequisites such as obtaining an approval_id from list_pending_approvals.

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

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

With no annotations, the description carries the full burden and does add useful behavioral insight: the tool runs a two-phase worker-then-reviewer flow and returns worker_task and reviewer_task objects. However, it omits auth requirements, behavior on worker/reviewer failure, timeout semantics, and whether delegation is recursive (depth hints at this but is unexplained).

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 purpose sentence is front-loaded and the Args/Returns structure is easy to scan. It is appropriately sized with no obvious padding, though the Args listing partially duplicates the structured schema.

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

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

The description covers the purpose, all parameters, and a return shape; the output schema existing means return values need not be detailed further. For a 6-param delegation tool with no annotations, the main residual gap is the missing when-to-use guidance rather than missing mechanics.

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

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

Schema description coverage is 0%, so the description must compensate, and it does so by explaining all six parameters (worker_id, reviewer_id, task, context, timeout, depth). Minor gap: context is described as a 'JSON object' while the schema types it as a string with default "{}", a slight mismatch.

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

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

The description states a specific two-phase verb+resource: delegate a task to a worker, then have a reviewer critique the work. This is clear and actionable. However, it does not explicitly distinguish itself from close siblings like delegate_task, debate_task, or pipeline_task, leaving the agent to infer the difference.

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 delegate_task, debate_task, or pipeline_task, nor any prerequisites or exclusions. The description only says what it does, not when it is the right choice.

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

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

With no annotations, the description carries the full burden; it helpfully enumerates the eight allowed categories (not present as enums in the schema) and shows the return envelope. But it omits key mutation semantics: whether writing an existing key overwrites, dedup behavior, permission requirements, and side effects. Useful but incomplete for a write tool.

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

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

Purpose is front-loaded in the first sentence, and the Args block earns its space given 0% schema coverage. The Returns section duplicates the existing output schema and could be trimmed, but overall the structure is efficient.

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

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

For a 7-parameter tool with no annotation coverage, the description covers purpose, all parameters, and the return shape, which is close to sufficient. The main gap is idempotency/overwrite behavior on duplicate keys, which an agent calling 'save' would want to know.

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

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

Schema coverage is 0%, so the description does the heavy lifting by documenting all seven parameters, including the category enumeration values and the meaning of project, key, tags, source_agent, and metadata. It reconciles somewhat with the string-typed schema by calling value/tags/metadata JSON-serializable, though the type mismatch (string vs list/object) is not fully clarified.

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?

States a concrete verb+resource ('Write a categorized memory entry') that clearly separates it from the read/delete siblings (get_memory, search_memory, delete_memory). It does not explicitly name those alternatives, so it falls short of full sibling differentiation.

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

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

The line 'BlackBox does not automatically store everything' implies the agent should call this deliberately rather than assume persistence, which is useful contextual guidance. However, it never states when to use this versus get_memory/search_memory or what triggers a save, leaving usage to inference.

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

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

No annotations are provided, so the description carries the behavioral burden. It usefully discloses that tags are AND-matched ('all must match') and that query searches across key/value/tags/metadata, plus the return envelope shape. However it omits ranking, pagination, or scope constraints beyond the filter fields.

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?

Front-loaded one-line summary followed by clearly labeled Args and Returns sections. Every line is informative and there is no filler, though the Args block partially restates parameter names.

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 an output schema present, return values need not be explained (though they are), and all five parameters are covered. The remaining gap is the absence of guidance tying this tool to its siblings and any operational constraints.

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

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

Schema description coverage is 0%, so the description must carry all parameter meaning, and it does: each of the five params is documented, adding semantics beyond the bare schema (tags is a JSON list where all must match, query spans key/value/tags/metadata, limit caps results at a default of 50).

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?

States a specific verb (search) and resource (memory) plus the dimensions it can filter on (project, category, tags, free text). It implicitly distinguishes itself from write siblings like save_memory and delete_memory, though it never names an alternative such as get_memory for direct 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?

No explicit when-to-use or when-not-to-use guidance. The description never explains how this differs from get_memory (single entry) or list_memory_categories, leaving the agent to infer the appropriate context from the filter list alone.

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

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

With no annotations, the description carries the full behavioral burden, and it does meaningful work: empty strings leave text fields unchanged, and capabilities/permissions/metadata are explicitly lossy replacements of current values. It omits auth/permission requirements, error behavior on an invalid assistant_id, and reversibility, which keeps it from a 5.

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 critical no-op/sentinel rules are front-loaded before the Args block, and the per-parameter lines are terse given the 0% schema coverage. Minor redundancy: the header says both temperature and max_tokens accept "0 or -1" to clear, while the per-field lines assign -1 to temperature and 0 to max_tokens, which reads as inconsistent.

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?

An output schema exists, so "Returns: JSON result" is acceptable, and the parameter coverage is thorough. The remaining gap is contextual routing: the overlap with enable_assistant/disable_assistant is left unaddressed.

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

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

Schema coverage is 0% across 12 parameters, so the description must compensate entirely, and it does — every parameter is named with its meaning, plus the non-obvious semantics (empty string = no change; -1 clears temperature, 0 clears max_tokens). This goes well beyond what the bare schema conveys.

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 line states a specific verb and resource ("Modify an existing assistant"), which cleanly separates it from create_assistant, delete_assistant, and get_assistant. It stops short of explicitly routing against the enable_assistant/disable_assistant siblings that overlap with its own `enabled` field.

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?

It gives a real usage rule — "Provide only the fields to change" — which is genuinely actionable. However, it never says when to prefer this tool over enable_assistant/disable_assistant (which toggle the same state exposed via `enabled`), and no prerequisites or exclusions are stated.

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

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

With no annotations, the description carries the behavioral burden and it does well on two fronts: it discloses that empty endpoint/api_key_env leave values unchanged, and that options are MERGED rather than replaced. However, it omits error/not-found behavior, permission requirements, and gives only the vague 'Returns: JSON result'.

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 summary sentence is front-loaded, and the Args/Returns structure is easy to scan with zero filler. Slightly redundant to restate 'Returns: JSON result' when an output schema exists, but overall efficient.

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

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

For a four-parameter partial-update tool, the description covers every parameter including the important partial-update merge/empty semantics. An output schema exists so return values need not be detailed, though the missing when-to-use context leaves a small gap.

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

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

Schema description coverage is 0%, so the description must carry all parameter meaning and it does: name is the existing provider id, endpoint is the new base URL, api_key_env is the new env-var name, and options is a JSON object merged into existing options. Every one of the 4 params gets clear semantics plus the empty-value convention.

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

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

The description states a specific verb (update) and resource (an existing provider) plus the fields that can change, making the operation unambiguous. It does not explicitly distinguish itself from create_provider/delete_provider, but the 'existing' qualifier makes the difference inferable.

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 siblings like create_provider or delete_provider, nor any prerequisites such as needing an existing provider id. The only implied usage comes from the word 'existing'.

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