Nebelus

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

Annotations already establish readOnly=false and destructiveHint=false, so the description is not responsible for the safety profile. It adds one boundary ('does not publish the agent itself') that is a genuine behavioral clarification. However, it does not discuss reversibility, whether deactivation impacts existing traffic, or any permission requirements, so the added transparency is minimal.

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

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

The text contains two tight sentences with zero waste. The primary verb + resource is front-loaded, and the differentiating 'does not publish the agent itself' is a meaningful clarifier, not 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?

For a simple 2-parameter toggle with no output schema, the description is largely sufficient: it covers the operation and its boundary. It could still mention what activation/deactivation actually changes for the channel, but given low complexity and no output schema, the remaining gaps are minor.

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

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

Schema description coverage is 100%: both 'active' and 'deployment_id' are already fully documented. The description adds no parameter-specific meaning beyond what the schema does, so the baseline of 3 is appropriate.

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

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

The description opens with 'Activate or deactivate a deployment channel', which clearly identifies the action and the resource. The closing clarification 'Serves the CHANNEL; it does not publish the agent itself' distinguishes it from agent-publishing/creation siblings, so an agent can tell it apart from create/update_deployment and validation tools.

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

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

The description gives useful context ('Serves the CHANNEL') but does not explicitly tell an agent when to use this tool versus alternatives like update_deployment, probe_deployment, or activate_governance_policy. There is no 'when not to use' exclusion or a pointer to a sibling, so usage guidance is implied rather than 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?

Annotations already mark the tool as not read-only and not destructive. The description adds that the operation is a live state toggle between draft and active, which is non-obvious context. However, it stops short of explaining what 'live' changes in practice or any side effects of deactivation.

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

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

The description is two short sentences with the core operation front-loaded and no filler. Every phrase contributes, including the parenthetical state transition.

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 two-parameter toggle, the description plus schema covers the mechanics. It is less complete on when to use it versus governance siblings and what 'live action' implies for the agent, so the full context is not quite there.

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

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

Schema description coverage is 100%, and the schema already documents active's boolean meaning and policy_id's purpose. The description reinforces the active-to-state mapping but adds no new parameter details beyond the schema.

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

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

The description states a clear verb ('Activate or deactivate'), a specific resource ('governance policy'), and the exact state transition ('draft <-> active'). This makes the operation unambiguous and distinguishes it from creation or policy assignment siblings.

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

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

No guidance is given about when to use this tool versus set_governance_policies, create_governance_policy, or other governance-related siblings. 'Activation is a live action' only hints at an effect; it does not state when this tool is appropriate.

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

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

Annotations already flag the operation as destructive, and the description adds valuable context beyond that: the action is reversible, it does not delete the agent, and the status is changed to archived. This clarifies the exact behavioral impact without contradicting the annotations.

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

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

The description is two sentences with no filler. The primary action and effect are front-loaded, followed only by the essential reversibility note.

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 single-parameter, low-complexity action with annotations indicating destructive behavior, the description covers purpose, effect, reversibility, and non-deletion. Nothing critical for correct invocation 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 100%, so the input schema already fully documents agent_id, including where to obtain it. The tool description adds no parameter-specific detail, but the schema carries the burden adequately.

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

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

The description uses a specific verb ('Take an agent offline') with a clear resource and outcome, and distinguishes the action from unarchive_agent and deletion. 'Setting its status to archived so it stops serving' precisely defines the behavior.

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 explicitly states when to use the tool (to stop an agent from serving) and gives alternatives/limits: 'Reversible with unarchive_agent; does not delete the agent.' This tells the agent it should use unarchive_agent for reversal and confirms this is not a deletion operation.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, implying the operation is not read-only but not destructive either. The description says 'Bind' which implies a mutation but does not state the dynamic nature (e.g., whether it's reversible or requires agent creation). It does not contradict annotations, and adds some context about the relationship but not behavioral details like idempotency or error conditions.

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

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

The description is one short sentence, which is concise and front-loaded. It is appropriately sized for a simple binding operation. No unnecessary words. The title and description are clear, but given the simplicity, it could be slightly expanded to include usage guidance without losing conciseness.

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

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

With a simple 2-parameter operation, no output schema, and high schema coverage, the description is adequate but not complete. An agent might need to know if attaching an AI tool has prerequisites (e.g., the tool must exist) or side effects. Given the low complexity, this is acceptable but could be improved.

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

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

Schema coverage is 100% and both parameters have descriptions. The description adds no additional meaning to the parameters beyond 'Bind'. The schema already documents that tool_id is an AI tool id and agent_id is the target agent's id. So the description does not add value; baseline 3 aligns with high schema coverage.

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

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

The description states a clear verb and resource ('Bind' and 'AI tool' to the agent). It does not differentiate from sibling tools like attach_sub_agent or attach_mcp_server, but the resource type is specific enough. A score of 3 is appropriate because it lacks explicit differentiation from similar attach tools, but purpose is evident.

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 use this versus alternatives. However, the context is clear: it binds an AI tool to an agentanglophone. With many sibling attach tools, a description of when to choose this over attach_sub_agent would be valuable, but the purpose is implied by the name and description. This is minimal guidance.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false, openWorldHint=false) and do not convey meaningful behavioral detail. The description only repeats the action ('attach') without disclosing side effects, prerequisites, reversibility, or failure conditions. An agent is left to infer that attaching is a persistent linkage operation without additional 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?

One sentence, no filler, front-loaded with the action. Every word contributes to the core message. The description is appropriately sized for the tool's simplicity.

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 low-complexity tool with two well-documented parameters and no output schema, the description is sufficient to convey the purpose and allow correct invocation. It does not mention edge cases or side effects, but these are not critical given the simple attach operation and minus number of parameters.

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

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

Schema coverage is 100%, so both parameters (agent_id and endpoint_id) already have descriptions in the input schema that explain their provenance (list_agents, get_catalog). The tool description does not add any parameter-specific information beyond what the schema provides, so it meets the baseline of 3.

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 ('Attach'), a specific resource ('existing custom API-endpoint tool'), and the target ('the agent'), which is clear and unambiguous. It explicitly differentiates this from sibling attach tools (attach_mcp_server, attach_ai_tool, etc.) by naming the API-endpoint tool type, so an agent can confidently select it.

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 makes the resource type explicit ('existing custom API-endpoint tool'), which implies it should be used when the user wants to attach an API endpoint. It does not, however, provide explicit 'when not to use' guidance or name alternatives, leaving some inference to the agent. Given the clear resource classification among many attach siblings, this is adequate.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false), so the description carries the burden. It only adds the constraint that the connector must be active, but does not disclose any side effects, whether it overrides existing attachments, or any permission requirements. This is insufficient for a mutation tool with no annotation-derived safety profile.

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?

A single, clear sentence with no extraneous information. The purpose is front-loaded, and the clarification about tenant-authored Python tool is concise and adds value without bloat.

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 2-parameter tool with no output schema, the description is adequate but lacks important context. It does not mention preconditions (e.g., agent exists), idempotency, or failure behavior. Given the complexity, it could benefit from additional usage and behavioral details.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description does not add additional meaning beyond what the schema provides, aside from reinforcing 'active' which is also in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the action (attach), the resource (code connector), and the target (agent). It also clarifies what a code connector is (tenant-authored Python tool), which distinguishes it from other attach_* siblings like attach_api_endpoint or attach_mcp_server. The verb is specific and unambiguous.

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

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

The description does not provide any guidance on when to use this tool versus the many other attach_* tools. It does not mention that this is for Python-based code connectors only, nor does it offer exclusions or alternatives. The agent must infer from the sibling names, which is not sufficient for clear selection.

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

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

Annotations already signal that the operation is not read-only and not destructive. The description adds the prerequisite that the file must already be uploaded, which is useful context, but does not disclose other behavioral traits such as idempotency, error conditions, or side effects on an existing attachment.

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?

A single, non-redundant sentence that front-loads the key action and object. It adds relevant constraint ('already-uploaded') rather than repeating the title, so every word earns its place.

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

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

For a low-complexity mutation with two fully documented parameters and no output schema, the description plus annotations cover the essential information needed to call the tool correctly: what is attached, to whom, and under what precondition.

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

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

Schema description coverage is 100%: each parameter is documented with its role and source. The description contributes no additional parameter-level meaning, so the baseline of 3 applies.

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

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

States a specific verb ('attach'), a specific resource ('already-uploaded file'), and a target agent. This clearly distinguishes it from sibling attach_* tools (e.g., attach_vector_store, attach_mcp_server) and from detach_file.

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 'already-uploaded file' implies the file must have been uploaded before this tool is used, providing an implicit usage condition. However, the description does not explicitly state when to choose this tool over alternatives or when not to use it.

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

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

The description states that attaching the server makes its tools available to the agent, which is the key behavioral effect. The annotations are minimal (no readOnlyHint, no destructiveHint), so the description carries the burden and adequately discloses the side effect. It also implies resource association without destroying anything, consistent with annotations.

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

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

The description is a single concise sentence that directly states the purpose‘s verb and resource, front-loading the core action and outcome. Every word earns its place, with no fluff or redundancy.

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

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

Given that this is a simple binary operation with only two well-documented parameters and no output schema, the description is complete enough. It covers the purpose and result. However, it could benefit from a note about idempotency (e.g., what happens if the server is already attached) or permissions, which would make it fully 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?

The input schema already provides complete descriptions for both parameters (agent_id and server_id) with sources. The description adds no additional parameter-level meaning beyond what the schema states, so the baseline of 3 applies given 100% schema coverage.

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

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

The description clearly states the action (attach) and the resource (an existing MCP server) and the purpose (make its tools available to the agent). It distinguishes it from create_mcp_server (creating vs attaching) and from other attach_* tools by the specific resource type, though it doesn't explicitly differentiate from those siblings.

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

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

The description implies the tool is for attaching server resources that already exist, which is clear from the word 'existing'. However, it does not provide explicit guidance on when to use this over alternatives like create_mcp_server or when not to use it (e.g., if the server is already attached). No mention of prerequisites like the server being available or whether agents need specific permissions.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, but they do not fully convey the mutating nature. The description clarifies that this is a binding action that changes the parent agent's wiring, which is useful. However, it does not disclose side effects such as whether previous bindings are overwritten, whether the operation is reversible (detach_sub_agent exists), or whether permissions are required. Given that annotations are present but sparse, this is adequate but not comprehensive.

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

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

The description is a single, concise sentence that front-loads the core action and purpose. It avoids redundancy with the schema, states the two binding modes, and stays within reasonable length. It could potentially mention the sibling detach tool, but that's not essential for 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?

Given that this is a binding operation with five parameters and no output schema, the description is relatively complete. It tells the agent the purpose and modes, and the schema handles parameter semantics. However, it lacks guidance on when to choose 'as_tool' vs 'handoff' and does not mention potential constraints (e.g., cannot bind to itself) that are already in the schema. For a moderately complex tool, this is acceptable but not exhaustive.

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

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

Schema description coverage is 100%, so all five parameters (agent_id, sub_agent_id, mode, instruction, stream_to_client) are already documented in the schema with descriptions. The tool description itself adds no new information about parameters, so the baseline of 3 applies. It correctly does not repeat schema details, but it also does not add extra context about parameter relationships (e.g., mode requires certain combinations).

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 begins with a clear verb ('Bind') and resource ('another of this org's agents to this one'), and it specifies the two binding modes (callable tool or handoff target). This distinguishes it from attach_ai_tool and attach_mcp_server, which are about external resources. However, it could be more explicit that it is specifically about agent-to-agent wiring, but the first sentence is unambiguous.

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

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

The description implies when to use it (when you want to attach one agent to another) but does not explicitly state when NOT to use it or mention alternatives like detach_sub_agent for removal. The input schema's required fields imply the context, but there's no direct guidance on selecting this over sibling attach_* tools beyond the resource type.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the description doesn't need to restate safety. The description adds the behavioral context that the attachment enables retrieval, which is useful. However, it doesn't disclose whether attaching replaces an existing store, whether it's idempotent, or whether it requires the agent to be in a certain state.

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

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

The description is a single sentence that front-loads the action and purpose. It is concise and free of fluff, though it could add a brief note about alternatives without becoming verbose.

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

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

For a simple two-parameter attach operation with full schema coverage, the description is adequate. However, it doesn't mention the effect of attaching (e.g., whether it replaces existing attachments) or any prerequisites, and there is no output schema to clarify the return value. The sibling list shows many attach_* variants, so a brief differentiator would improve completeness.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds no additional meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description states a specific verb ('attach') and resource ('vector store (knowledge base)') and clarifies the purpose ('so the agent can retrieve from it'). It distinguishes from siblings like detach_vector_store and create_vector_store, though it doesn't explicitly name 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?

The description implies the tool is used to give an agent retrieval access to a knowledge base, and the sibling list shows related attach_* tools. However, it doesn't explicitly state when to use this over attach_file or attach_mcp_server, nor does it mention prerequisites like the store needing to exist or be created first.

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

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

Annotations are minimal (no read-only, destructive, or open-world hints implied), so the description carries meaningful weight. It discloses that the output is always a draft, that it returns the editable surface plus assumptions, and that it is billed as AI credits at the build rate. This adds useful behavioral context beyond the annotations, though it leaves out details like permissions or lifecycle implications.

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

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

The description is three purposeful sentences with no filler. It front-loads the core purpose, then adds return behavior, differentiation from create_agent, and billing context, with each sentence contributing valuable 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?

The description is nearly complete for selecting and invoking the tool: it explains what input to provide, what output to expect, and how it differs from the main sibling. It does not detail error cases or exact response structure, but the lack of an output schema is partially mitigated by the explicit mention of the returned editable surface and assumptions.

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

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

Schema coverage is 100%, so the schema already documents both parameters clearly. The description reinforces that prompt is a plain-language request and mentions constraints, but it doesn't add meaningful new semantic detail beyond the schema definitions.

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

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

The description clearly states this tool builds an agent from a plain-language prompt, invoking a specific verb and resource. It explicitly differentiates itself from create_agent by noting the latter requires explicit fields and that build_agent synthesizes the agent.

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 clear guidance on when to use this tool: when describing an agent in plain language with AI assistance. It names the alternative create_agent and contrasts the required input style, giving the agent enough context to choose correctly.

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

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

Annotations already declare destructiveHint=true, and the description's 'Cancel' is consistent. The description clarifies the scope ('one of the agent's scheduled tasks') but does not disclose side effects or irreversibility. Given the destructive hint, this is acceptable; the description adds some value but not extensive behavioral context.

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

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

The description is a single, concise sentence that front-loads the action. It is appropriately sized—no redundant words—though it could arguably include a note about cancellation being irreversible, but that would be optional. It is efficient and well-structured.

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

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

For a simple destructive operation with only two parameters, both fully documented in the schema, and with annotations indicating destructiveness, the description is adequate. It tells the agent exactly what the tool does. The absence of an output schema suggests minimal return value, and the description does not need to explain that.

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?

Both parameters have full descriptions in the schema (100% coverage) explaining how to obtain them (e.g., from list_agents and list_schedules). The description only adds 'by id', which is redundant given the schema. Thus the description provides minimal additional meaning beyond the schema.

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

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

The description states a clear verb ('Cancel') and a specific resource ('one of the agent's scheduled tasks by id'). It unambiguously identifies the action and distinguishes it from sibling tools like set_schedule and list_schedules by focusing on cancellation.

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

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

The description implies when to use the tool (when you want to cancel a scheduled task), but it does not explicitly state when not to use it or mention alternatives. The parameter descriptions in the schema add context about obtaining the schedule_id, but the description itself offers no exclusions or comparisons to other tools.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the mutation safety profile is covered. The description adds valuable behavioral context beyond annotations: the created agent is always a draft, publishing is intentionally outside this tool's scope, and no deploy tool exists. This is exactly the kind of non-obvious behavioral disclosure that helps an agent avoid a wrong workflow.

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

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

Two sentences with zero waste. The core action is front-loaded, and the critical constraint (draft-only, no deploy) is stated immediately after. Every sentence earns its place.

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

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

For a create tool with no output schema and no nested objects, the description covers the essential workflow context: creation always results in a draft, and publishing is a human console action. It doesn't describe the return value, but with no output schema and a simple create operation, that is a minor gap. The sibling context (build_agent, update_agent, activate_deployment) further clarifies where this tool fits.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no parameter-specific meaning beyond the schema, but it doesn't need to; the schema descriptions are clear. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Create a new agent') and immediately clarifies the critical scope constraint: it always lands as a draft. This distinguishes it from sibling tools like build_agent, update_agent, and activate_deployment, and makes the tool's purpose unmistakable.

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

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

The description explicitly says when to use this tool (to create an agent) and, more importantly, what not to expect: publishing is a human act in the Nebelus console and no deploy tool exists here. This prevents an agent from searching for a nonexistent publish/deploy step and clearly routes expectations.

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

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

Annotations indicate a non-read-only, non-destructive operation, and the description adds meaningful constraints: only static, non-secret headers are allowed, and auth must be set by reference. It also clarifies that this tool creates rather than attaches, so creating and wiring the endpoint are separate steps.

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

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

Two sentences with no filler. The first sentence front-loads the purpose and primary constraint, and the second gives actionable next steps, so every sentence earns its place.

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

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

For a creation tool with 13 parameters and no output schema, the description does not state what the call returns or whether special permissions are required. The lifecycle and constraints are clear, but the missing outcome/return context leaves a meaningful 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 100%, so the description need not restate parameters. It does add a specific constraint on `static_headers` and auth, but leaves the remaining parameters to the schema, which is acceptable given the high coverage.

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

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

States a specific action and resource: 'Create an outbound custom API-endpoint tool in the org'. It also distinguishes from related siblings by noting that attachment (`attach_api_endpoint`) and auth (`set_endpoint_auth`) are separate tools, so an agent can tell exactly which step this tool covers.

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

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

Provides clear lifecycle guidance: after creation, use `attach_api_endpoint` and `set_endpoint_auth`, and never inline secrets. It does not explicitly compare against `create_mcp_server` or `update_api_endpoint` when choosing the tool, but the create-vs-update and API-endpoint-vs-MCP distinctions are reasonably 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?

Annotations indicate a write (readOnlyHint=false) and non-destructive (destructiveHint=false), but the description adds crucial behavior: creation is a draft, does not publish, and requires separate activation. It also surfaces an org-type restriction not present in annotations. No contradiction.

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?

Three sentences, each carrying distinct info: purpose, non-publication, activation, and an eligibility constraint. No redundancy or filler, and the core purpose is front-loaded.

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

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

Covers core behavior, non-publication, activation pathway, and a key constraint. Lacks explicit return-value description, but no output schema exists, and for a draft-creation tool this is acceptable given the strong parameter coverage.

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

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

Schema coverage is 100%, with every parameter having a description (including the nested config). The tool description adds no parameter-level detail beyond the schema; the web-widget mention reinforces an enum value but doesn't explain 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?

Verb 'create' + resource 'deployment channel' + qualifier 'DRAFT' makes the purpose unambiguous. It explicitly states it does NOT publish, and names activate_deployment as the activation step, distinguishing it from siblings like update_deployment and probe_deployment.

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?

Names the companion tool activate_deployment and explains the draft/activation split, giving clear context for when to use this tool. Also discloses an eligibility rule (identity-unverified self-serve orgs → web-widget only), which guides channel selection. Does not explicitly say when to avoid it, but the activation mention implies the workflow.

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

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

Annotations only convey readOnlyHint=false and destructiveHint=false; the description adds valuable unstated behavior: the policy is created in draft form and not effective until activated, and configuration fields are validated against the PII registry. This meaningfully affects the caller's expectations of side effects and failure modes.

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

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

Two sentences that each carry important information: the draft/activation lifecycle is front-loaded, and the validation caveat is brief but material. There is no filler or redundant restatement of the 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 create-style tool with 5 parameters, a nested configuration object, no output schema, and sparse annotations, the description covers the key runtime behaviors: draft state, separate activation, and registry validation. The only minor gap is that it doesn't hint at the return value on success, which is customary for creation tools.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds genuine meaning by explaining that `configuration` is policy-type-specific and that masked_fields/pii_entities are registration against the PII registry. This goes beyond the schema's generic 'settings' wording and helps correctly construct nested values.

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

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

The description clearly states a specific verb and resource ('Create a DRAFT governance policy in the org') and highlights the draft/active split, which distinguishes it from the sibling tool activate_governance_policy. It also scopes the object to org-level policy creation, removing ambiguity left by the generic name.

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

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

The description explicitly instructs that activation must be done separately with activate_governance_policy, providing clear lifecycle guidance on when this tool is appropriate. It does not explicitly exclude other policy-related siblings like set_governance_policies, but it makes the create-then-activate workflow unambiguous.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false, destructiveHint=false). The description adds the non-secret headers constraint, which is also present in the schema, and the purpose. It does not disclose response behavior, idempotency, or any side effects beyond creation. Given annotations cover the basic safety profile, the description adds modest value but no deeper behavioral context.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, then adds a constraint and purpose. No redundant or filler content; every word earns its place.

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

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

For a create operation with no output schema, the description conveys the essential purpose and a key constraint. It does not elaborate on post-creation steps (like attaching tools) but that is covered by sibling tools. The tool's complexity is moderate, and the description is sufficient for an agent to understand when and how to use 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 100%, so all six parameters are well-documented in the schema. The description's mention of 'non-secret headers only' aligns with the schema's custom_headers description but does not add new parameter-specific meaning. With high coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Register' and the resource 'a new MCP server', and specifies the scope 'in the org'. It also adds the purpose 'so its tools can be attached to agents', which distinguishes it from sibling tools like attach_mcp_server (which attaches an existing server) and update_mcp_server (which modifies an existing one).

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

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

The description provides clear context: it is for creating a new server, and the purpose of enabling attachment to agents implies the subsequent workflow. However, it does not explicitly state when NOT to use this tool (e.g., 'if the server is already registered, use attach_mcp_server instead'). The implied usage is strong 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so no contradiction. The description adds the key behavioral detail that the store is initially empty and that files are added via a separate tool, but it doesn't mention any permissions, return values, or other side effects beyond the creation 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 two short sentences: the first front-loads the tool's purpose and the second gives a direct follow-up tool reference. Every word serves a purpose and there is no fluff.

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

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

For a simple two-parameter creation tool with complete schema coverage and no output schema, the description is sufficient. It even points to the next step (ingest_file_to_store) to close the workflow loop. It doesn't explain how to retrieve the created store's ID, but that's not essential for invocation.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description does not add additional parameter semantics beyond saying it creates an empty store; it doesn't clarify how name or metadata are used beyond what the schema states.

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 ('Create a new, empty vector store (knowledge base) in the org'), and it distinguishes itself from siblings like create_agent or attach_vector_store by specifying that it creates an empty store that is later populated via ingest_file_to_store.

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

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

The description clearly implies a workflow: create the store first, then ingest files using ingest_file_to_store. It provides context on when to use this tool, though it does not explicitly exclude alternatives like attach_vector_store for existing stores.

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

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

Annotations already flag destructiveHint=true, and the description strengthens that by stating the deletion is 'permanent' and disclosing the detach-then-delete side effect when force is used. This goes beyond the annotation by telling the agent how the tool behaves in the attached-agents scenario.

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 short sentences, each earning its place: the first states the destructive core action, and the second handles the one important conditional case. No filler or irrelevant detail.

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

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

For a destructive two-parameter delete with annotations present and no output schema, the description covers the essential behavioral points: permanence, attachment scenario, and use of force. Parameter details are fully covered in the schema, so no critical invocation information appears 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 coverage is 100% and the schema already explains force behavior ('Detach from any agents first, then delete. Default false (fails if still attached).'). The description reinforces the force meaning but does not add substantial parameter semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Permanently delete a vector store', which makes the action and object unambiguous. This clearly separates it from sibling tools like update_vector_store, attach_vector_store, and detach_vector_store, since those do not delete the store itself.

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

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

The description provides clear operational context: use force=true to detach-then-delete when the store is still attached to agents. It does not explicitly point to detach_vector_store for cases where the store itself should be kept, which would have made the guidance fully explicit, but the core when-to-use condition is well conveyed.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the context that this endpoint is a discovery/registry read returning machine-readable data, and the warning that 'nothing here is an instruction' protects against misuse. No contradiction with annotations.

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

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

Two sentences, with the core identifier 'machine-readable build surface reference' front-loaded. The long list of contained data is information-dense rather than padding, and the second sentence adds a necessary usage directive with no 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?

For a zero-parameter discovery tool, the description is remarkably complete: it specifies the full set of returned categories, notes machine-readability, and gives the call-order guidance. Even without an output schema, an agent knows what to expect and why to call it.

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 is no schema to document or coverage gap to compensate; the 100% schema coverage and empty object make parameter guidance unnecessary. Baseline 4 applies.

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

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

The description defines the tool as a 'machine-readable' reference for the build surface and enumerates the specific data it exposes: capability registry, settable agent fields, guardrail keys, Build Envelope, deployment channel types, and identity state. That specificity plus 'Call this first' and 'nothing here is an instruction, only data' distinguishes it from the many mutating sibling tools.

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

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

It explicitly tells the agent to 'Call this first to discover the full surface,' establishing a clear when-to-use instruction. It also signals that the content is 'only data,' so the agent should not treat output as commands. It does not name alternative tools or articulate when to prefer a sibling, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, indicating this is a destructive mutation. The description adds no additional behavioral context beyond what annotations provide—it does not mention reversibility, side effects, or what happens to the unbound tool. Since the description carries no extra value, this is a minimal score.

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

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

The description is a single sentence with zero waste, stating the core action without superfluous details. It is appropriately front-loaded and efficient for a simple detach operation.

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

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

Given the tool's simplicity (two required parameters, no output schema), the description covers the basic action. However, it does not mention any side effects or outcomes (e.g., whether the tool is deleted or remains available for reattachment), and it provides no disambiguation from sibling detach tools. For a tool with destructive annotations, a bit more context would improve completeness, but it is not severely lacking.

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

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

Schema description coverage is 100%, with both tool_id and agent_id having clear descriptions. The tool description itself adds no parameter-level information, but the schema already documents them adequately. Baseline 3 is appropriate given the high schema coverage.

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

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

The description uses a specific verb 'Unbind' and names the resource 'an AI tool from the agent', making the action clear. However, it does not distinguish this from sibling detach tools like detach_api_endpoint or detach_file, relying on the tool name for differentiation. The description is direct and unambiguous.

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

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

There is no guidance on when to use this tool versus the many sibling detach tools (detach_api_endpoint, detach_file, etc.). The description merely states the action without providing context on prerequisites, alternatives, or conditions. An agent would have to infer usage from the tool name alone.

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

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

The detach action is consistent with the annotations (`readOnlyHint=false`, `destructiveHint=true`), so there is no contradiction. However, the description reveals nothing beyond the bare mutation and does not say whether the endpoint is deleted, remains available, or can be reattached.

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

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

The description is a single, clear, front-loaded sentence with no filler, repeated phrases, or unnecessary details.

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

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

The schema and annotations cover important basics, and the tool is low in complexity, but the description still leaves gaps around preconditions, side effects, and when exactly the tool should be called. It is minimally adequate rather than fully self-sufficient.

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

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

The schema already fully describes both parameters with 100% coverage, including agent_id and endpoint_id. The description adds no additional meaning, so the baseline score of 3 applies.

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

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

The description names a specific action ('Detach'), a specific object ('custom API endpoint'), and its source ('from the agent'), so it can be distinguished from sibling tools like attach_api_endpoint, detach_vector_store, and detach_sub_agent without inspecting the 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?

There is no guidance on when to use this tool versus alternatives. It does not mention the inverse attach_api_endpoint, name any preconditions, or warn that the endpoint must currently be attached.

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

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

The description adds no behavioral detail beyond what the annotations already indicate (destructiveHint=true, readOnlyHint=false). It does not state whether the operation is reversible, what happens if the connector is already detached, or any side effects, leaving the actual behavior ambiguous.

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?

A single, declarative sentence that is front-loaded with the action and resource. No wasted words, and the structure is clean and easy to parse.

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

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

For a simple 2-parameter tool with destructive annotation, the description conveys the basic operation but omits important context: whether the connector is deleted or merely unlinked, expected output or errors, and any reversibility. Without an output schema, the agent must assume the behavioral details, which is a moderate 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?

The input schema provides complete documentation for both parameters, including how to obtain agent_id and what connector_id references. The description itself adds no further parameter semantics, so it defaults to the baseline for complete schema coverage.

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

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

The description states a specific verb 'Detach' and the resource 'code connector', with the target 'agent'. This clearly identifies the operation and differentiates it from other detach-* tools by naming the exact resource type, though it does not explicitly mention sibling alternatives or scope limits.

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

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

No guidance is provided about when to use this tool versus when not to, no prerequisites are mentioned, and the description does not reference related operations like attach_code_connector. An agent is left without context to decide when this tool is appropriate.

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

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

Although annotations already indicate destructiveHint=true, the description adds value by clarifying that the operation only detaches the file and does not delete the underlying uploaded file. This reduces the perceived destructiveness and correctly sets expectations for the agent. No contradiction with annotations.

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

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

The description is a single sentence with no unnecessary wordsienne`, and the key clarification about not deleting the file is naturally included. It is well-structured and front-loaded with the main action.

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

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

For a two-parameter tool with annotations already covering the destructive hint, the description is adequate. It could be improved by stating whether the file must be currently attached or by referencing the attach_file counterpart, but it is not critically 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?

The schema provides descriptions for both parameters (file_id and agent_id), so with 100% schema coverage the baseline is 3. The description does not add extra meaning beyond what the schema states, but it also does not need to.

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

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

The description clearly states the tool's action ('Detach a file') on a specific resource ('from the agent') and includes an important clarifying note that the uploaded file itself is not deleted. This distinguishes it from other detach_* tools, though siblings like detach_ai_tool are differentiated by resource type in the name.

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

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

The description implies usage for detaching a file from an agent, but does not explicitly state when to use it versus other detach_* tools. It also does not mention any prerequisites, such as needing the file to be currently attached, though the schema does provide the required parameters.

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

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

Annotations already mark destructiveHint=true, and the description adds no further behavioral context such as reversibility, impact on the server configuration, or whether the server remains available for re-attachment. It does not contradict the annotations, but it also does not enrich them.

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

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

A single, front-loaded sentence with no filler. It conveys the action and target resource efficiently.

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 two-parameter detach operation, the description is minimally adequate, and the destructiveHint annotation covers safety. However, it lacks any mention of side effects or post-condition state, which would make it fully 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?

Input schema covers both parameters with descriptions, so the baseline is 3. The tool description adds no parameter-level detail beyond what the schema already provides.

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

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

Description states a specific verb ('Detach'), a specific resource ('an MCP server'), and the scope ('from the agent'). This clearly differentiates it from siblings such as attach_mcp_server and detach_ai_tool.

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

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

No explicit guidance about when to use this tool versus alternatives or prerequisites. The verb implies removal, but there is no stated inverse relationship with attach_mcp_server or warning about when not to detach.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is covered. The description adds no extra context (e.g., side effects, permissions, reversibility) beyond what annotations provide, so it earns minimal credit.

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

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

The description is a single, succinct sentence with no wasted words. It front-loads the action and object, making it immediately scannable for an agent.

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 two-parameter tool with destructive annotations and no output schema, the description is sufficient to guide correct invocation. It could mention the prerequisite that the sub-agent is currently attached, but that is reasonably implied by 'previously attached.'

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

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

Schema coverage is 100% with clear descriptions for both agent_id and sub_agent_id. The tool description itself adds no parameter-specific meaning, so it meets the baseline for schema-heavy documentation without extra compensation.

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

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

The description clearly states the action (unbind) and the resource (sub-agent), distinguishing it from other detach_* tools by the specific object type. It is concise and unambiguous, though it does not explicitly name sibling tools for differentiation.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, such as detach_file or detach_vector_store. It only implies the resource type, relying on the agent to infer that this is the correct tool for removing a sub-agent binding.

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

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

The annotations already flag destructiveHint=true, so the destructive nature is known. However, the description adds no further context about what 'detach' entails—whether the store is deleted, if the operation is reversible, or what side effects occur. It simply restates the action without elaborating on consequences.

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

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

The description is a single, efficient sentence with no superfluous wording. It is front-loaded and earns its place, though it may be slightly under-specified given the operation's implications.

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

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

For a destructive operation with two required parameters, the description lacks important context: what happens to the vector store upon detachment, whether the action is reversible, and any side effects. The annotations cover the destructive hint, but the description does not elaborate on the operational impact.

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

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

Schema description coverage is 100%, so both agent_id and store_id are fully documented in the schema. The description adds nothing about parameters, so the baseline of 3 is appropriate—the schema carries the semantic load.

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

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

The description clearly states the verb 'detach', the resource 'vector store', and the target 'agent'. It is specific enough to convey the core operation, though it does not explicitly differentiate from sibling detach_* tools beyond the resource type, which is inherent in the name and 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention that it is the inverse of attach_vector_store, nor any conditions or prerequisites for detaching. The description leaves usage entirely 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?

The description lists operations like remove_node and remove_edge which obviously have destructive behavior, and annotations already carry destructiveHint=true. It adds useful preconditions (agent must be workflow) and explains parameter defaults (e.g., edge kind defaults to 'flow'), but it does not disclose whether edits are reversible, whether validation happens prior to commit, or whether the change is local/global. The bar is lower because annotations already declare destructive intent, but the behavior is only partially transparent.

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 condensed and effective; the core purpose and precondition appear first, then the op-perop field mappings. It is denser than one might like due to the semicolon-separated list, but it avoids repetition and every segment conveys the required mapping. It could be better formatted with line breaks, yet is still an appropriately sized spec.

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

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

For a complex tool with six dynamic ops, the description covers all relevant context: the significant constraints (workflow agent, valid endpoints, node types), the complete op→fields matrix, and default values. There is no output schema, and the description does not pretend to specify return formats, but nothing an agent needs to know in order to call the correct op and pass correct parameters is omitted.

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?

While the input schema only formally defines op and agent_id, the description exhaustively explains the additionalParameters structure for every op: add_node, update_node, remove_node, add_edge, remove_edge, set_state_field, including optional fields and defaults (e.g., kind? default 'flow', field_type? default 'str'). This meaningfully compensates for the schema's additionalProperties:true being a black box, and gives an agent the exact data shapes required for each case.

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 opens with a specific, action-oriented statement: 'Apply ONE granular edit to a workflow agent's graph.' It names the resource ('a workflow agent's graph'), the key precondition (pattern_type=workflow), and distinguishes this from sibling tools like update_agent or build_agent by defining the granular op vocabulary. This leaves no ambiguity about what the tool does.

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 context is clearly provided: the tool is for making a single granular edit against a graph, and requires the agent to be pattern_type=workflow. However, it does not explicitly name alternatives such as 'use update_agent instead for broader edits' or give a when-not-to-use statement. The intent is conveyed but not fully routed against siblings.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description correctly inherits the safety profile without over-explaining. It adds useful behavioral detail by framing the output as an 'editable surface' designed to be fed back into update_agent, which shapes expectations about the return 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?

The entire purpose is conveyed in a single, front-loaded sentence with zero filler. Every phrase earns its place: 'one agent' limits scope, 'editable surface' describes the returning shape, and the update_agent reference documents the round-trip contract.

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 one-parameter fetch tool with readOnly and destructiveHints provided, this description is close to complete. The only unmentioned details are error/not-found behavior and exact return schema, but the 'round-trippable with update_agent' phrasing signals the return format sufficiently.

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

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

Schema description coverage is 100%, and the only parameter agent_id is well-documented with its source providers. The description adds nothing specific about the parameter itself, so the baseline of 3 applies because the schema carries the full semantic weight.

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: 'Fetch one agent's editable surface'. The phrase 'one agent' clearly distinguishes it from list_agents while 'editable surface' and the reference to update_agent define it as the read-for-editing counterpart to get_catalog, get_wiring, and probe_agent.

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 communicates when to use this tool by noting that its result is 'round-trippable with update_agent', effectively making it the fetch step before an edit. This is clear context, though it does not explicitly name alternatives or list when-not-to-use 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context: the Build Envelope filtering (out-of-envelope options are never advertised) and the mode=overview behavior returning the app map. No contradiction.

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?

A single well-structured sentence with semicolon-separated details. The primary purpose is front-loaded, and every clause earns its place without redundancy.

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

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

For a read-only catalog retrieval with 3 parameters, 2 enums, and no output schema, the description covers the views, the filter, and the mode behavior. Combined with annotations, nothing essential 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 coverage is 100% and all parameters have descriptions. The description restates the views, query, and mode but adds no new meaning beyond the schema (e.g., the 'app map' phrasing is already in the schema). Baseline of 3 applies.

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

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

The description states a specific verb+resource ('The organization's served catalog') and clearly distinguishes from siblings by enumerating the exact views (models, tools, agents, etc.). It also adds a scoping constraint (Build Envelope) that separates it from generic list tools.

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

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

It tells you what it returns (views, query, mode) and implicitly covers when to use it (to browse the catalog). However, it does not explicitly contrast with alternatives like list_agents or get_agent, though the enumerated views make the boundary clear.

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

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

The read-onlyHint and destructiveHint annotations already cover the safety profile, and the description adds the useful behavioral detail that results are 'region-correct for the org' and enumerates the returned categories. There is no contradiction between description and annotations, but no deeper behavioral context such as output format or potential errors is disclosed.

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

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

The description is a single focused sentence that front-loads the purpose ('How to wire this agent into an app') and then lists the key outputs. Every part adds value, with no filler or redundant restatement of schema details.

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

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

Given no output schema, the description compensates by enumerating the main categories of returned wiring information and noting the read-only nature. It is sufficiently complete for an agent to understand what to expect, though exact response formatting and potential edge cases are not described.

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

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

The input schema fully documents the single required parameter, agent_id, with a clear description. The tool description does not add meaningfully beyond that, so the schema carries the parameter-semantics burden; a baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as returning deployment wiring details for an agent, listing concrete items such as REST endpoint, WebSocket URL, webhook triggers, embed snippet, and MCP connection. It is more specific than just restating the tool name, though it does not explicitly differentiate from siblings like get_agent or probe_deployment.

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

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

The description implies when to use this tool: when you need connection/wiring information for an agent. It does not provide explicit guidance on when not to use it or which sibling tool to prefer instead, so the usage context is clear but not fully directive.

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

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

The description goes beyond annotations by stating that the operation runs asynchronously and that processing is in-region. It also clarifies that chunking and embedding occur, which is not present in the annotations. It does not explain how to monitor completion, but the async trait is a meaningful behavioral disclosure.

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

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

The description is a single sentence with no filler. It front-loads the main purpose, includes important operational details, and earns its place without redundancy.

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

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

For a two-parameter tool, the description provides enough to invoke it correctly: the target store, the file to ingest, and the async behavior. The lack of an output schema is not a major issue, though a note on how to observe completion would make it fully 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 100%, with clear descriptions for both file_id and store_id. The tool description adds no additional parameter-level semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Ingest') with a clear object ('already-uploaded file') and target ('vector store'), and adds 'chunk + embed' to clarify the operation. It is clearly distinguishable from sibling tools like attach_file or create_vector_store.

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 'already-uploaded file' implies a prerequisite, and 'into a vector store' indicates the target. However, there is no explicit when-to-use guidance, no exclusions, and no comparison to related tools such as attach_file or attach_vector_store.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe read-only nature is covered. The description adds useful behavioral context by specifying the response fields and that both Drafts and active agents are included, extending beyond what annotations provide.

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

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

The description is one compact sentence plus one clarifying fragment flag. Every word earns its place: verb, scope, fields, and statuses. No filler or redundant restatement.

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

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

For a zero-parameter, read-only list operation with no output schema, the description provides enough: scope, return fields, and included statuses. Nothing essential is missing for an agent to invoke it correctly.

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

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

There are zero parametersasi, and schema coverage is trivially 100%, so the description has no parameter burden. It still adds value by listing the output fields, which aids interpreting the result.

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

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

The description clearly states the verb ('List'), the resource ('this organization's agents'), and the returned fields (id, name, status, model). It also notes the included statuses (Drafts and active), which distinguishes this collection operation from singular siblings like get_agent.

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 conveys that this tool lists agents for the organization, but it does not explicitly state when to prefer it over alternatives such as get_agent or when not to use it. The usage context is implied rather than directly articulated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the return fields (name, cadence, next run), which is useful behavioral context beyond the annotations. It doesn't disclose pagination or ordering, but for a simple list tool this is acceptable.

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?

One short sentence with the key information front-loaded: what is listed, for whom, and what fields are returned. The 'Read-only' tag is a useful addition with no wasted words.

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

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

For a simple read-only list tool with one fully documented parameter and no output schema, the description is nearly complete. It could mention that the output is a list of schedules, but the verb 'List' already implies that. The read-only annotation covers the safety aspect.

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

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

Schema description coverage is 100%, so the schema fully documents the agent_id parameter. The description doesn't add parameter-level detail, but the baseline of 3 applies because the schema carries the burden. The description's mention of 'the agent's' tasks aligns with the parameter's purpose.

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'), resource ('scheduled tasks'), and scope ('the agent's'). The parenthetical '(name, cadence, next run)' clarifies the return fields, and 'Read-only' reinforces the operation type. It is clearly distinguishable from siblings like set_schedule and cancel_schedule.

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

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

The description implies the tool is for reading an agent's schedules, and the read-only hint plus sibling names (set_schedule, cancel_schedule) make the contrast clear. It doesn't explicitly state when not to use it or name alternatives, but the context is sufficient for an agent to select it correctly.

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

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

Annotations already indicate the operation is not read-only and not destructive; the description adds the important billing context ('billed as a test run'), but it doesn't disclose whether the test run creates state, logs, or has other side effects on the draft agent. This is acceptable but could be richer.

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?

A single, front-loaded sentence that conveys the action, target, outcome, and billing implication with no wasted words.

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

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

The tool is simple, both parameters are fully documented by the schema, annotations cover safety semantics, and the description explains the tool's purpose and billing side effect. Everything an agent needs to call it correctly is present.

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

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

Schema description coverage is 100%, with both 'message' and 'agent_id' clearly described in the schema. The description's phrasing adds light context ('test message', 'draft') but doesn't meaningfully go beyond the structured parameter definitions.

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 ('Send a test message') and identifies a precise resource ('a draft'), while clarifying that the tool returns the real runtime reply. It naturally distinguishes itself from siblings like probe_deployment by targeting drafts rather than deployments.

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

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

The description clearly conveys when to use the tool: when you need to test a draft agent with a real message and get the runtime's reply. It does not explicitly name alternatives or when-not-to-use conditions, but the draft-vs-deployment framing makes the intended context clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavior by specifying it is a dry-run check and discloses the exact two-gate verdict ('deployment active + agent servable'). No contradictions, and the added detail goes beyond what annotations alone provide.

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

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

The description is a single, well-structured sentence that front-loads the purpose ('Dry-run check') and includes the key outcome ('two-gate verdict') and safety property ('Read-only') with no 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?

For a simple, read-only tool with one parameter and no output schema, the description provides enough information: it names the action, the outcome, and the read-only nature. An agent can call this tool correctly without needing more context.

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

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

Schema coverage is 100% and the parameter description in the schema is clear ('Id of the deployment to probe.'). The tool description adds no further parameter semantics, so baseline 3 is appropriate.

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

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

Description states a specific verb ('probe', 'dry-run check') and resource ('this deployment'), and clarifies the purpose: 'would this deployment serve right now?'. It clearly distinguishes from sibling tools that activate, create, or update deployments, and from probe_agent by focusing on deployment servability.

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

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

The description provides clear context: this is a dry-run, read-only check to determine if a deployment would serve. It implies use before activation or as a diagnostic, but does not explicitly name alternatives or state when not to use it, so it falls short of the top score.

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

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

Annotations signal readOnlyHint=false and destructiveHint=false, so the mutation profile is already known. The description adds the security-critical behavior 'BY REFERENCE (never inline secrets)' and the fallback behavior when use_endpoint_auth=false; it could still disclose overwrite/conflict behavior, but the added context is meaningful.

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

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

Two sentences front-load the core security rule and then compactly list the three invocation modes. Every clause maps to parameters or behavior; no 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?

For a tool with 7 parameters, a nested object, and no output schema, the description covers the principal modes and the secret-handling constraint, and the schema fills in parameter detail. It does not state what happens when none of the mode parameters are supplied or what the response is, but these are acceptable gaps given the strong schema and mode enumeration.

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

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

With 100% schema coverage, the schema already explains each field. The description adds cross-parameter semantics by defining the three mutually relevant modes: auth_profile_id reuse, auth_method+auth_config inline definition, and use_endpoint_auth=false clearing. This is more than the schema's per-field documentation.

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 identifies a clear verb+resource: 'Point an agent's attached API endpoint at authentication' and enumerates three outcome modes (reuse, inline, clear). It is unambiguous about what the tool does, though it does not explicitly contrast it with siblings like update_api_endpoint or attach_api_endpoint, so it stops 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?

It offers explicit in-tool usage direction: reuse an AuthProfile, define one inline, or clear the override, and ties each mode to specific parameters. There is no explicit when-not-to-use or sibling alternative, so it doesn't earn a 5.

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

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

The description discloses the key behavior beyond the annotations: 'mode=replace sets the exact list; add/remove adjust it.' This reveals that replace will entirely redefine the policy set and add/remove will incrementally modify it. That is meaningful behavioral context that annotations only hint at through the readOnly/destructive flags.

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

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

Two sentences with no filler. The purpose is front-loaded and the mode clarifications follow naturally. Every word earns its place.

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

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

For a 3-parameter mutation tool with complete schema descriptions and no output schema, the description is sufficiently complete. It conveys the core side-effect of replace mode and the adjust behavior for add/remove. It does not mention authorisation requirements, but the annotations cover the basic read/write/destructive profile.

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?

Although the input schema already covers all parameters, the description adds value by explaining the nuances of the mode enum: replace means exact list, while add/remove adjust it. This goes beyond the schema's generic phrase about applying policy_ids and helps an agent pick the right mode.

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: 'Attach existing governance policies to the agent.' It clearly distinguishes from sibling tools like create_governance_policy and activate_governance_policy by emphasizing the policies already exist. No ambiguity in what operation is being performed.

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 makes the usage context clear by saying 'existing governance policies' and by defining the three modes: replace, add, and remove. It does not explicitly name alternatives, but the 'existing' qualifier and mode semantics tell an agent when this tool is appropriate versus creating/activating policies.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, but they do not capture the nuance that this is a configuration tool that can turn off a feature (potentially 'destructive' in a functional sense). The description adds valuable context: the tool is 'Assistive, never a certification,' which qualifies the feature's role, and it explicitly mentions disabling via 'disable=true', which behavioral transparency. It adds context about modes (e.g., manual reviewer trace, agent self-check) that go beyond annotations. No contradiction.

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

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

The description is a compact three-sentence block with no fluff. The first sentence states the primary action and purpose, the second clarifies the nature (assistive, not certification), and the third gives a quick usage tip ('Pass disable=true'). It is front-loaded with the main purpose, and every sentence earns its place. Efficient for 6 parameters.

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

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

Given the tool's complexity (6 parameters, one required) and the fact that the output schema is absent, the description covers the core purpose and the disable mechanism. However, it does not explain what happens when disabling (e.g., does it affect existing traces?), nor does it mention the default modes (manual, agent_invoked). The schema provides parameter details, but a richer description could contextualize the modes (e.g., mode 1 vs mode 3) to help agents make informed choices. Still, enough for basic invocation is present, so 4 is appropriate.

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

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

Schema coverage is 100%, so the schema already documents all 6 parameters with descriptions. The description adds meaning by clarifying the purpose of the feature and the disable flag but does not delve into each parameter's semantics beyond what the schema already provides. However, the description does not repeat parameter details, which is fine, but it also doesn't add new insights about parameters like report_language or inference_prefix. Given high coverage, baseline 3, but the description gives a high-level purpose that helps interpret the parameters, so 4 is justified.

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 exactly what the tool does: enable, tune, or disable Grounding Trace (claim-to-source verification) on an agent, with a clear qualification that it is 'Assistive, never a certification.' This is specific (verb 'set' or 'enable/tune/disable' + resource 'Grounding Trace on the agent') and distinct from siblings like set_governance_policies or attach_ai_tool. It clearly differentiates itself by focusing on the trace feature.

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

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

The description implies usage context: it is for regulated report output that needs claim-to-source verification, and it mentions how to disable (pass disable=true). However, it does not explicitly state when to use this versus alternatives, nor does it provide exclusions (e.g., when not to use it). The guidance is clear but implicit rather than explicit about competing choices.

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

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

Annotations only say readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the description carries the burden of explaining behavior. It discloses the update-by-name semantics, the exclusivity of cadence forms, the deterministic one-tool behavior of TOOL mode, and the clearing of instruction when action_tool is set. It does not mention failure modes or validation errors, but the core behavioral traits are well covered.

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 compact and front-loaded: it states the core action first, then the exclusivity rule, then the mode distinction. Every sentence earns its place, and the use of backticks and capitalization ('EXACTLY ONE') makes the critical constraint scannable. No filler or repetition of schema content.

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

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

For a 15-parameter tool with no output schema, the description covers the essential decision points: which cadence form to use, which mode to use, and the update-by-name behavior. It does not explain return values or error handling, but the absence of an output schema lowers the bar. The description is complete enough for an agent to construct a valid request.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by grouping parameters into cadence forms and modes, but it does not add much beyond the schema's own per-parameter descriptions. The grouping is helpful for understanding mutual exclusivity, but the schema already documents each parameter individually.

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 ('Create or update') and resource ('a scheduled run of the agent'), and immediately distinguishes the two modes (AGENT vs TOOL) and the four mutually exclusive cadence forms. It clearly differentiates from siblings like cancel_schedule and list_schedules by focusing on creation/update semantics.

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

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

The description explicitly says to provide EXACTLY ONE cadence form, names all four alternatives, and explains when to use AGENT mode (instruction) vs TOOL mode (action_tool+action_params). It also notes that reusing a name updates the schedule in place, which is a key usage rule. This is strong guidance for an agent deciding how to invoke the 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?

Annotations only say readOnlyHint=false. The description goes further and exposes the key behavioral nuance: this is a full overwrite, so any omitted webhook trigger is removed (creates/disables live webhook rows). That is exactly the kind of consequence an agent must know before invoking.

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

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

Two sentences carry the definition: the first states action and semantic effect, the second states the call-style restriction. Zero filler and the most important information (replacement semantics) is front-loaded.

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

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

For a write-only setter with 2 fully documented parameters and no output schema, this description is complete enough. It covers what the tool does, how it behaves, and the one critical trap (omitted triggers are removed). It could mention return behavior or idempotency, but those are not needed for a normal agent invocation.

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

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

The schema already has 100% description coverage for both parameters, including the 'complete list' and 'only one blank-slug default webhook' constraint. The description adds value by reinforcing that the list is the whole desired state, not a patch delta. This is useful but not drastically new after the strong schema.

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

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

The description uses a specific verb 'Replace' and clarifies the resource: the agent's trigger list. This clearly distinguishes it from siblings like set_schedule or set_governance_policies, and the parenthetical about live webhook rows puts the tool in a specific configuration niche.

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 instruction to 'Send the full desired list' and the warning that 'omitted triggers are removed' establishes a clear usage protocol: do not just update, replace. It doesn't explicitly mention when not to use the tool or name an alternative, but the replacement semantics give enough context for correct selection and invocation.

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

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

Annotations only indicate readOnlyHint=false and destructiveHint=false. The description adds behavior by specifying the state change (archived → draft) and the consequences (editable and re-publishable). It does not contradict annotations and provides useful context beyond the structured 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?

A single, efficient sentence that front-loads the core action and outcome with no superfluous words. Every part 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?

For a single-parameter tool with annotations covering safety, the description is sufficient: it explains what it does, why it's useful, and the resulting state. It doesn't cover edge cases like the agent not being archived, but that is a minor gap given the tool's simplicity.

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

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

Schema description coverage is 100%, so the schema already fully describes the agent_id parameter. The description adds no additional meaning about the parameter, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb ('bring back'), the resource ('an archived agent'), and the outcome ('to draft status so it can be edited and re-published'). This distinguishes it from siblings like archive_agent, which performs the opposite action.

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

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

The description implies the usage context (for agents that are archived) and mentions the benefit (editing and re-publishing). However, it does not explicitly state when not to use it or name the alternative (archive_agent) as a contrast. It is clear enough but lacks explicit exclusion 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?

Given the minimal annotations (readOnlyHint:false, destructiveHint:false), the description adds a useful behavioral trait: rejected fields are 'refused with reasons' rather than silently accepted — a meaningful expectation-setting disclosure. It does not reveal, however, whether updates are atomic or what happens to the draft after a successful update (e.g., revalidation), so it is below 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 description is two short sentences, front-loaded with the action and resource, with zero filler. The parenthetical field sample is efficient and illustrative, and the refusal clause earns its place as a high-value guardrail; a small deduction for not weaving in the alternative-tool routing that the schema has to supply separately.

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

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

For a tool with a large nested-object parameter and rich field semantics, the combination of the description's boundary statement and the 100%-covered schema is nearly sufficient. The main gap is the missing output-side info (no output schema exists and the description never hints what a successful call returns), plus no guidance on draft-state requirements (the title implies drafts only), but overall the agent can call 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 100%; the schema already documents the partial-map semantics, the full accepted-field list, key-wise merge behavior, and the refused-field list, so the description's parenthetical field sample adds no new parameter meaning. This is the baseline 3 for high schema coverage — the schema does the heavy lifting.

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

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

The description states a specific verb and resource ('Update a draft's fields') with a concrete sample list of field categories (model, tools, system message, knowledge), which immediately signals what the tool operates on. It also draws a boundary against sibling tools by explicitly listing refused properties (status/workflow/organization/user), so an agent can distinguish it from build_agent, create_agent, attach_* and set_* tools without opening schemas.

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

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

The description provides a clear when-not-to-use signal: status/workflow/organization/user fields are refused, so an agent knows not to route those updates here. However, it does not name the alternative tools (attach_*/set_* tools) in the description itself — that routing guidance lives in the schema's fields description, which is a minor gap against the rubric's explicit when/alternatives criterion.

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

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

Annotations already show this is mutating but not destructive. The description adds the partial-update behavior ('send only the fields to change'), which is useful context. It doesn't discuss response, side effects, or permissions, but with annotations covering the safety profile this is acceptable.

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 concise sentences with no filler. The action is front-loaded and the key usage instruction follows immediately.

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 partial-update tool with a fully documented schema and clear annotations, the description is adequate. It covers the operation type and the update pattern; the required endpoint_id is visible in the schema, and there is no output schema to describe.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the patch semantics and references create_api_endpoint for the field set, but doesn't need to restate individual parameter meanings since the schema already documents them.

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 action ('Patch an existing custom API endpoint') with a clear verb and resource. It distinguishes itself from create_api_endpoint by saying 'existing' and referencing the same field set, so an agent can tell update from create without opening schemas.

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 an explicit usage rule: send only the fields to change. It also points to create_api_endpoint as the reference for the field set, establishing an update-vs-create context. It doesn't explicitly name alternatives like set_endpoint_auth, but the main use case is clear.

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

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

The description adds a valuable behavioral detail beyond the annotations: config_patch merges key-wise and explicit null deletes a key. While this is also in the schema's description, it is a critical semantic trait that prevents an agent from treating config_patch as a full replacement. Since readOnlyHint=false and destructiveHint=false are already in the annotations, this extra merge context is the main enrichment.

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

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

The description is a single, well-formed sentence that starts with the action and primary fields, then adds the essential config_patch semantics. There is no wasted phrasing or repeated metadata. The parenthetical is tightly integrated and necessary for correct invocation.

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 full schema documentation and read/write/destructive hints provided in annotations, the description is mostly sufficient, but lacks discussion of what happens when the deployment_id doesn't exist, whether the operation is idempotent, or what kind of response is returned (no output schema is present). These modest gaps keep it from being fully complete for an agent invoking the tool cold.

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

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

The input schema already provides 100% coverage of all four parameters, including descriptions like 'New name.' and 'Partial config to merge in (key-wise; null removes a key).' The description lists these fields and repeats the merge behavior, but it adds no meaning beyond what the schema already conveys. This is the baseline 3 for strong schema coverage.

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

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

The description states a clear verb: 'Patch a deployment's name/description/config.' It identifies the resource and the specific fields, which distinguishes it from sibling tools like create_deployment or activate_deployment. It doesn't explicitly name the alternatives, so I don't give a 5, but the primary 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?

The description implies this is for modifying an existing deployment, but gives no explicit direction on when to use it versus create_deployment or update_agent. An agent must infer the intended context from the resource name and the word 'patch'. It is minimally adequate, but lacks any 'when-not-to-use' 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?

The description adds the behavioral detail that only provided fields are updated (partial update), which is valuable beyond the annotations (readOnlyHint=false, destructiveHint=false). However, it does not disclose other behavioral traits such as error handling, idempotency, side effects on connected resources, or what the response looks like. Given that annotations already indicate a non-destructive mutation, the description provides only modest additional disclosure.

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

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

The description is a single, tightly written sentence. It front-loads the essential information (patch operation) and the most important usage detail (send only changed fields). No filler or redundancy. It earns a perfect score for 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 patch operation with a complete schema and minimal annotation, the description covers the core requirement: perform a partial update using the create field set. However, it lacks additional context such as whether the server must already exist, what happens on failure (e.g., 404), or the shape of the response. An agent might need to infer these or look elsewhere. Given the tool's moderate complexity, a few more details would make it more complete.

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

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

Schema description coverage is 100% – each parameter is already described (url, name, server_id, transport). The description adds context that only the provided fields are changed, but it does not add any new meaning to individual parameters beyond what the schema provides. The reference to create_mcp_server's field set is helpful but not strictly necessary since the schema is complete. Baseline of 3 is appropriate.

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

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

The description clearly states the action (patch/update), the target resource (existing MCP server), and the key behavior (partial update). It also references the sibling create_mcp_server for the field set, which distinguishes it from that creation tool and other update tools among the siblings.

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

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

The description provides explicit usage guidance by stating to send only the fields to change and pointing to create_mcp_server for the allowed field set. This tells the agent how to structure the request. However, it does not mention when not to use the tool (e.g., if the server does not exist or when full replacement is needed), so it lacks explicit exclusions or alternative routing.

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

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

Annotations provide readOnlyHint=false and destructiveHint=false, so the description carries some burden. It discloses that the operation is an update ('rename or re-tag'), but does not explain side effects such as whether metadata is replaced entirely or merged, or if name changes affect references. No contradiction with annotations, but behavioral detail beyond the basic operation is missing.

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

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

The description is a single concise sentence that leads with the action and specifies the resource. No waste, and it effectively conveys the core 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?

For a simple update operation with no output schema, the description covers the essential purpose. It doesn't specify whether metadata is merged or replaced, but that is a minor gap given the tool is straightforward and the schema clarifies parameters. Overall adequate for an agent to invoke correctly.

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

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

Schema coverage is 100%: the schema already describes name as 'New display name,' metadata as 'Freeform metadata to set,' and store_id. The description's 'rename or re-tag' adds little beyond the schema. Baseline 3 is appropriate since schema covers all parameters.

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

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

The description states a clear verb ('Rename or re-tag') and a specific resource ('existing vector store'), which distinguishes it from create_vector_store and delete_vector_store. It is specific and unambiguous about what the tool does.

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

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

The description implies usage (when you want to modify an existing vector store) but does not explicitly mention alternatives or exclusion conditions. It doesn't say 'use create_vector_store to create a new store' or 'use delete_vector_store to remove.' Guidance is embedded but not stated, so it earns a 3.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds important extra behavior: it doesn't run the agent, returns problems found (with empty meaning ready), and checks model allow-listing. This goes beyond the annotations to clarify side effects and output semantics.

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 concise sentences front-load the key purpose (pre-flight validation) and immediately list the checks and return semantics. No filler or redundant wording.

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 single-parameter, read-only, no-output-schema tool, the description completely covers scope, side effects, return values, and what makes it suitable for pre-flight checks. The annotations carry the safety profile, and the description covers everything else needed to invoke it correctly.

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

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

Schema coverage is 100% and the single parameter agent_id has a useful description. The tool description adds no additional parameter guidance, but none is needed; the schema fully documents this required field.

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

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

The description clearly identifies the tool as a pre-flight validation for agent drafts, listing each check it performs (workflow-graph validity, tool resolution, model allow-list). While sibling tools like probe_agent exist, this description distinguishes it by explicitly stating it does not run the draft.

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 'Pre-flight a draft without running it' implies use before execution/deployment, but it does not explicitly name sibling tools (e.g., probe_agent) or state when NOT to use this tool in favor of another. The guidance is adequate but mostly inferred rather than explicit.

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