NoLag MCP

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

With no annotations, the description carries the full burden. It discloses the behavior of the webhooks themselves (when they fire) but not the behavior of the configure operation—e.g., whether it overwrites existing config, whether it's idempotent, what authorization is needed, or what it returns. This is a significant gap for a mutating tool.

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

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

The description is two sentences, front-loaded with the primary purpose, and each clause adds value by explaining the two webhook types. There is no redundancy or filler.

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

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

The description covers the core purpose and distinguishes the webhook types, but given no annotations, no output schema, and nested config objects, it lacks crucial context: the structure of the webhook config objects, update semantics, and return behavior. This is minimally complete for a configuration tool.

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

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

The input schema descriptions cover 100% of parameters, including detailed explanations of triggerWebhook and hydrationWebhook. The tool description merely restates those semantics ('Hydration webhooks are called when actors subscribe...') without adding new meaning, 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-resource pair ('Configure webhooks for an app') and clearly distinguishes the two webhook types (hydration and trigger) with their invocation triggers. This sets it apart from sibling tools like get_webhook_config (read) and list_webhook_dlq (monitor).

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

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

The description explains when each webhook type is relevant (subscription vs. message publish), providing clear context for when to use this tool. However, it does not explicitly name alternatives such as get_webhook_config for reading current configuration, so it stops short of full exclusionary 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 discloses the critical behavioral trait that the access token is shown only once, requiring immediate saving. However, with no annotations provided, the description carries the full burden and only covers this one behavior. It does not mention other side effects, response structure, or authorization requirements beyond the token.

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 exceptionally concise: two sentences with the purpose in the first five words. The token warning is critical and directly follows the purpose. There is no redundancy or wasted text.

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

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

For a create tool with 4 parameters and no output schema, the description is minimal but does include the crucial token warning. It lacks usage context, what constitutes a successful response (beyond the token), and any prerequisites. While the core purpose is clear, an agent would need additional information for full autonomous 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 input schema has 100% coverage with descriptions for all parameters, including examples for 'name' and an enum for 'actorType'. The description adds no parameter-specific details, 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 'Create a new actor' with a specific verb and resource. It distinguishes from sibling tools like create_agent or create_app, which target different entity types. The name and title align perfectly with the described 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 gives no guidance on when to use this tool versus alternative create tools. The only additional sentence is a warning about saving the access token, which is a post-creation action, not a selection criterion. No context about prerequisites or situations where this tool is preferred is provided.

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

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

No annotations are available, so the description carries the full burden of disclosure. It reveals two important behavioral traits: sessions survive disconnects and queued messages are delivered on reconnect, plus the access token is only shown once. These are non-obvious and critical for safe usage, though it doesn't mention permissions or reversibility.

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: the first states the core purpose, the second provides a critical operational warning. It is front-loaded, free of fluff, and every word contributes value.

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

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

There is no output schema, so the description partially compensates by highlighting the one-time access token. The parameters are fully documented in the schema, and the description covers the most important runtime behavior. It lacks a full return-value description but is reasonably complete for a create operation.

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 100% coverage with detailed descriptions for all 4 parameters. The tool description adds no extra parameter-specific meaning beyond what the schema already states, 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 begins with a specific action: 'Create an AI agent actor', clearly identifying the verb and resource. It further differentiates from siblings like nolag_create_actor by specifying 'persistent session support', making the tool's unique 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 implies when to use the tool (when an AI agent with persistent MQTT sessions is needed) but does not explicitly contrast it with alternatives like nolag_create_actor or state when not to use it. No clear exclusion or alternative guidance is provided, so usage context is 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.

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

No annotations exist, so description carries full burden. It states creation behavior and setup of rooms/topics, but does not disclose prerequisites (e.g., existence of Blueprint), side effects, idempotency, or permissions. For a mutation tool, this is a significant gap.

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

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

Two sentences, front-loaded with the core action, no filler. Every word contributes to explaining purpose and setup.

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?

Tool has moderate complexity (sets up rooms/topics) but no output schema. Description explains the concept but lacks details on pattern configuration specifics or post-conditions; still sufficient for basic understanding but not full contextual 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 already covers both name and description with brief descriptions (100% coverage). Description adds no extra parameter-specific semantics beyond the overall app context, so 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?

Description uses specific verb 'Create' + resource 'app' + qualifier 'from the agents Blueprint with pattern configuration', clearly distinguishing it from generic nolag_create_app. It also describes what is set up (rooms/topics) for agent communication.

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

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

No explicit when-to-use or alternative guidance. Context implies it's for apps needing agent communication patterns, but does not contrast with nolag_create_app or other siblings. This is an implied usage but not exclusions.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only states a mutation ('Create') without mentioning side effects, permissions, reversibility, or output. This is a significant gap for a tool that creates a persistent resource.

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 with no redundant words, making it easy to parse quickly. It is appropriately brief, though it sacrifices detail for brevity.

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

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

Given the tool's complexity (3 parameters, no output schema) and absence of annotations, the description is incomplete. It doesn't explain return behavior, relationships to sibling entities, or any preconditions, leaving significant gaps for an agent 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?

The input schema provides full descriptions for all three parameters (name, blueprintId, description), so the schema already covers the semantics. The tool description adds no extra parameter context, which keeps it at 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 clearly states the action ('Create') and the resource ('a new app'), distinguishing it from sibling create tools like nolag_create_actor or nolag_create_scope. However, it lacks additional context about what an 'app' represents in this project, so it doesn't fully differentiate beyond the resource 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?

There is no guidance on when to use this tool versus alternatives, such as nolag_create_agents_app or nolag_create_orchestrator. No prerequisites, exclusions, or alternative scenarios are mentioned, leaving the agent without enough information to choose between related create tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses a critical behavior—'The access token is only shown once - save it immediately!'—and also notes persistent sessions and multi-app access. This is substantial but doesn't cover all potential side effects or permissions.

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 sentences with no redundant wording. Every sentence adds value, front-loading the core purpose and then adding the crucial token caveat.

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

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

Despite having no output schema or annotations, the description covers the tool's purpose, key capabilities, and the critical security detail about the one-time token. It could mention prerequisites or returned data beyond the token, but it is reasonably complete for a creation tool.

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

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

All three parameters are fully described in the schema (100% coverage), so the description adds no additional parameter semantics beyond reminding about the token behavior. This meets the baseline but doesn't exceed it.

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

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

The description uses a specific verb+resource ('Create an orchestrator actor') and clearly distinguishes this from sibling tools like nolag_create_actor by noting it 'coordinates work across agents' and mentions persistent sessions and multi-app access. This makes its purpose unambiguous.

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

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

It provides clear context on when to use this tool: for orchestration requiring persistent sessions and multi-app access. However, it doesn't explicitly contrast with alternatives such as nolag_create_actor or state when not to use it, so it stops short of full 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?

Without annotations, the description only discloses that a room is created. It does not mention permissions, idempotency, behavior if the room already exists, or any side effects. Minimal behavioral detail beyond the action 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?

Highly concise at one short sentence, front-loading the primary action. However, it omits any qualifying detail, yet the brevity is acceptable for a simple creation tool.

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?

Description is minimal, with no output schema or annotations, and does not explain what a 'dynamic room' is, what the tool returns, or failure cases. For a create operation, more context about expected behavior would be needed.

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

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

The input schema has 100% description coverage, with name, appId, and description each documented. The description adds no additional parameter semantics beyond the schema, 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?

The description clearly states the action (create) and resource (dynamic room), scoped to an app. It distinguishes from sibling tools like update_room, delete_room, and list_rooms by indicating creation specifically.

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 no guidance on when to use this tool versus alternatives, such as update_room for modifying existing rooms or get_room for reading. The description merely states what it does, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden. It discloses that actors assigned to a scope get automatic communication isolation, which is useful behavioral context. However, it does not mention permissions required, idempotency, uniqueness of slug, or the return value. This is minimal but not misleading.

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 exactly two sentences, front-loaded with the primary purpose. Every word contributes value, and there is no repetition of schema or annotation information.

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

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

For a create tool without an output schema, the description explains the core concept and behavioral consequence (communication isolation). It does not describe the return value, but the tool's simplicity and complete input schema make this a minor gap. The overall context is adequate.

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

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

The schema covers all 4 parameters with detailed descriptions, including slug formatting rules. The description adds no additional parameter semantics beyond the schema, so 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 states the verb 'Create' and the resource 'access scope', with the specific purpose of tenant isolation. It also distinguishes this from sibling creation tools like create_actor or create_room by focusing on scope creation.

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 for when to use this tool: for creating access scopes that enforce tenant isolation. It does not explicitly mention alternatives or exclusion cases, but the surrounding sibling tools (update_scope, delete_scope) imply the create/read/update/delete pattern.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely states 'Delete an actor' without mentioning permanence, cascading effects, permission requirements, or error handling. This is a destructive operation and the lack of detail is a significant gap.

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

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

The description is a single, short sentence with no wasted words, making it extremely concise. However, its brevity borders on under-specification for a destructive operation, but conciseness itself is well-handled.

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 has no output schema and no annotations, and the description provides only the minimal 'Delete an actor'. It lacks essential context about side effects, permanence, and return behavior, making it incomplete for safe and effective use.

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

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

The input schema fully documents the only parameter (actorId with description 'Actor ID'), and schema coverage is 100%. The description adds no additional meaning beyond what the schema already provides, 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 'Delete an actor' clearly states the action (delete) and the target resource (actor), which distinguishes it from sibling tools like nolag_update_actor or nolag_get_actor. It also differentiates among delete_* tools by specifying the resource.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lacks prerequisites (e.g., actor must exist), warnings about irreversibility, or references to related tools like nolag_update_actor. There is no usage context at all.

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

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

With no annotations, the description carries the full burden. 'Soft delete' is a meaningful behavioral trait, but it does not explain what soft delete entails (e.g., reversibility, impact on list_apps, permissions, or side effects on related resources).

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

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

The description is extremely concise at five words, front-loaded with the verb and resource, and contains no filler or redundant information.

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

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

Given the simple one-parameter schema and no annotations, the description is minimally adequate. It states the core behavior (soft delete) but omits return values, error cases, permissions, and any post-delete effects, which would be useful for an agent.

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

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

The schema fully documents the single parameter appId with 'App ID', so baseline is 3. The description adds no further meaning about the parameter, such as format, origin, or validation.

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 ('Delete') with a clear resource ('an app') and adds the important qualifier 'soft delete', which distinguishes this from permanent deletion and from sibling tools like update_app or create_app.

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 alternatives, nor are prerequisites or exclusions mentioned. The description simply states the action without contextual usage direction.

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

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

With no annotations, the description carries full burden. It adds the key behavioral constraint that static rooms cannot be deleted, but does not disclose what happens on failure, whether deletion is permanent, or any permission requirements. This is minimal but non-zero 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?

The description is a single, focused sentence that includes a necessary qualifier. Every word earns its place, with no redundant or extraneous information.

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

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

For a simple delete operation with two well-documented parameters and no output schema, the description is mostly complete. It captures the essential limitation (dynamic vs static rooms) while remaining appropriately concise. Minor omissions include potential error behavior or side effects, but these are not critical for this tool.

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

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

The input schema already provides descriptions for both parameters (appId and roomId), and the description adds no further parameter-level detail. Since schema coverage is 100%, 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 clearly states the action ('Delete') and the specific resource ('a dynamic room'), and it distinguishes this tool from a generic delete room by noting that static rooms cannot be deleted. This differentiates it from sibling tools like nolag_update_room or nolag_get_room.

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: use this tool for dynamic rooms, and not for static rooms ('static rooms cannot be deleted'). It does not explicitly name an alternative for static rooms, but the exclusion is clear enough.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It reveals a key failure mode (actors still assigned) but does not address other aspects like reversibility, return values, or required permissions. The description adds some value but is 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 two sentences, front-loaded with the core action, and provides a critical constraint without waste. Every word contributes.

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 single-parameter delete tool with no output schema, the description is quite complete. It states the primary action and a necessary precondition/failure mode. It could mention idempotency or return type, but these are not critical for understanding how to invoke the tool.

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

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

The input schema has 100% coverage for the single parameter (scopeId) with description 'Access scope ID'. The tool description does not add additional meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the action: 'Delete an access scope.' It uses a specific verb and resource, distinguishing it from sibling tools like nolag_create_scope, nolag_get_scope, and nolag_update_scope.

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

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

The description provides usage context by noting the failure condition: 'Fails if actors are still assigned to it.' This implicitly tells the agent to ensure no actors are assigned before calling. It does not explicitly name alternatives, but the purpose is clear enough among siblings.

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

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

With no annotations, the description carries the full burden. It discloses the routing behavior ('routed to agents subscribed to the tasks topic with matching capability filters') but does not mention delivery semantics, failure handling, or whether the call returns a task identifier or just an acknowledgment. This is adequate but leaves behavioral gaps.

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

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

The description is two sentences, front-loaded with the primary action and purpose, and contains no redundant words. It efficiently conveys the tool's role and routing behavior.

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

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

For a dispatch tool with no output schema and no annotations, the description explains the core flow: envelope creation, publishing to a topic, and routing to agents. It could be more complete by mentioning what the caller receives (e.g., ack or task ID), but the complexity is moderate and the current text is sufficient for typical use.

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

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

Schema coverage is 100%, and the description adds meaning by explaining that 'capability' drives routing to matching agents and that 'payload' is the task envelope content. This connects the parameters to the tool's purpose beyond their raw schema descriptions, enhancing semantic understanding.

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

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

The description clearly states the tool's function: 'Publish a task envelope to a room's tasks topic' and 'dispatch work to NoLag-connected agents'. This is a specific verb+resource combination that distinguishes it from the broader nolag_publish sibling, as it focuses on task envelopes with capability-based routing.

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

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

The description explicitly says 'Use this to dispatch work to NoLag-connected agents from an MCP client', providing a clear when-to-use context. It does not explicitly mention alternatives or when-not-to-use, but the stated purpose is specific enough to guide tool selection among siblings.

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

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

There are no annotations, so the description carries the full burden of disclosing side effects, authentication needs, or output behavior. It merely states it generates code, but does not say whether it is read-only, whether it returns the code directly, or if any system state changes.

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 8-word sentence that is front-loaded with the action and object. No filler or redundant 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?

With no output schema, the description should explain what the generated code looks like or how it is returned, but it doesn't. It also omits how optional parameters like topics and framework affect the output, leaving the tool under-specified for practical use.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema. The description adds only a vague 'specific use case' hint for the useCase parameter and no additional meaning for appId, topics, or framework.

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 uses a specific verb ('generate'), names the resource ('SDK client code'), and scopes it ('for a specific use case'). This clearly distinguishes it from sibling tools focused on CRUD operations, webhooks, or task dispatch.

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

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

The description offers no guidance on when to choose this tool over alternatives or what prerequisites apply. It only says 'for a specific use case,' leaving the agent to infer applicability.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the basic action and does not disclose whether the operation is read-only, what happens on invalid actorId, response format, or any side effects. This is insufficient for an unannotated tool.

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

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

The description is a single, front-loaded sentence with no extraneous words. It earns its place by being concise and directly stating the tool's purpose.

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

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

Given the absence of an output schema and annotations, the description should convey what 'details' entails or the return structure. It does not, leaving the agent uncertain about the response. The tool is simple, but the description is too thin to be fully actionable.

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% (actorId is described as 'Actor ID'), so the baseline is 3. The description adds no extra meaning beyond what the schema already provides, merely aligning with 'specific actor'. It does not explain format or where to obtain the ID.

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

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

The description 'Get details about a specific actor' clearly identifies the verb (get) and resource (actor details). It is specific and unambiguous, but it does not explicitly differentiate from sibling tools like list_actors or get_app, so it falls short of a 5.

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

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

No usage guidance is provided. The description does not mention when to use this tool versus alternatives such as list_actors, nor does it state any prerequisites or context. This is a clear gap.

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

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

No annotations are provided, so the description carries the full burden. It only says 'get details' without explicitly confirming it is a safe read-only operation, what happens if the app does not exist, or any other behavioral expectations. The word 'get' weakly implies read-only, but this is not a substitute for clear 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?

One short sentence with no filler. It is appropriately front-loaded and easy to parse, with every word earning 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?

Despite being a simple one-parameter getter, the tool has no output schema and no annotations, so the description needs to explain what 'details' are returned. It does not, leaving a significant gap for the agent to decide if calling this tool will yield the needed information.

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 for the single parameter appId is 100% (type and description provided). The description adds no meaning beyond what the schema already documents, so it meets the baseline for high coverage but does not exceed it.

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

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

The description clearly states the action (get) and resource (app), and 'specific app' distinguishes it from list_apps. It is immediately obvious what this tool does and how it differs from sibling getters for other entity types.

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

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

No guidance is provided about when to use this tool versus alternatives like list_apps or other get_* tools. The description does not mention prerequisites, exclusions, or when this tool is preferred, so the agent has no explicit decision support.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clearly indicates a read operation and explains the return value as retained state messages. However, it does not mention permissions, error conditions, or what happens when the state is empty, leaving some gaps.

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

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

The description is two sentences, front-loaded with the primary action, and contains zero filler. Every word adds meaning, efficiently conveying the tool's purpose and return semantics.

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 tool with no output schema, the description adequately explains what it does and what it returns. It provides enough context for an agent to use it correctly, though it could elaborate on the structure of the returned state messages or edge cases.

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

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

The input schema covers all parameters with descriptions (100% coverage), so the description adds limited value. It does reinforce that 'key' is optional and 'room' is the scope, but the schema already provides this information.

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

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

The description clearly states the tool's purpose with a specific verb ('Read') and resource ('current blackboard shared state for a room'). It distinguishes itself from siblings by focusing on the blackboard concept and its key-value state visibility to all agents.

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 current shared state but does not provide explicit guidance on when to use this tool versus alternatives like nolag_get_messages or nolag_publish. No exclusions or alternative tools are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'get', which implies read-only, but does not disclose authentication needs, rate limits, whether messages are marked as read, or what 'recent' means (e.g., time window). This is a significant gap for a tool with no annotation support.

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

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

The description is a single, front-loaded sentence that directly states the tool's function. Every word contributes to meaning, and there is no wasted 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 simple getter with 4 parameters, the description is minimally adequate but lacks return value details, ordering, pagination, and usage context. With no output schema or annotations, more contextual guidance would be expected, such as indicating that limit controls count and that topic is an optional filter.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds context by mentioning 'room/topic', but this is ambiguous given that roomId is required and topic is optional. It does not clarify that roomId is mandatory or how topic relates to room, potentially misleading the agent.

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

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

The description 'Get recent messages from a room/topic' clearly identifies the action (get), resource (messages), and scope (room/topic). It is specific and distinguishes this tool from sibling tools like nolag_get_room or nolag_list_rooms, as no other sibling targets messages.

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 recent messages are needed, but provides no explicit when-to-use guidance or alternatives. It does not mention exclusions (e.g., historical messages, other scopes) or contrast with related tools like nolag_publish or nolag_list_agent_events.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation but does not state what 'details' means, whether the operation can fail (e.g., room not found), or any permissions required. This is a significant gap for a tool with no annotation support.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It is appropriately sized for a simple getter tool and is easy to parse at a glance.

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 has no output schema, so the description should clarify what 'details' will be returned. It does not. It also fails to mention any response format or error behavior. While the parameter set is simple, the lack of return-value context makes this incomplete for a tool that retrieves data.

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

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

The input schema already describes both parameters (appId and roomId) with 100% coverage, so the description does not need to repeat their semantics. However, it adds no extra meaning beyond the schema—for example, it does not explain the relationship between appId and roomId. Baseline 3 is appropriate given 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 ('Get') and resource ('details about a specific room'), which clearly indicates the tool's function. The qualifier 'specific' implicitly contrasts with the sibling tool nolag_list_rooms, but it does not explicitly name alternatives, so it doesn't fully achieve the 'distinguishes from siblings' bar.

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

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

The description provides no guidance on when to use this tool versus alternatives like nolag_list_rooms or nolag_get_messages. There are no explicit use cases, restrictions, or exclusions mentioned, leaving the agent to infer when this is the right choice.

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

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

No annotations are provided, so the description carries the full burden. It only implies a read operation via 'Get details' but does not disclose behavior for missing scopes, permission requirements, or the format of the returned details. This is minimal transparency for a tool with no structured safety hints.

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

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

The description is a single, direct sentence with no redundant words. It is front-loaded and efficient, earning the highest 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?

The tool is simple with one parameter and no output schema, but the description is minimal. It does not specify what 'details' includes or how errors are handled. While adequate for a basic getter, the lack of output schema and any contextual notes leaves clear gaps in completeness.

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

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

The input schema has 100% coverage for the single parameter scopeId with description 'Access scope ID.' The tool description adds no additional meaning beyond what the schema already provides, 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 'Get details about a specific access scope' uses a clear verb and resource. It distinguishes this tool from siblings like nolag_list_scopes (which lists scopes) and nolag_update_scope/delete_scope by focusing on fetching details for a specific scope.

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

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

No guidance is given on when to use this tool versus alternatives. The sibling nolag_list_scopes exists for listing scopes, but the description does not mention it or any exclusions, leaving the agent uninformed about the appropriate context for this getter.

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

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

No annotations are provided, so the description carries the full burden. The verb 'Get' suggests read-only, but the description does not disclose any additional behavioral traits such as authentication requirements, error conditions, or whether it returns the full configuration or a subset. This is minimal transparency beyond the verb 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 a single, efficient sentence that is front-loaded with the action and resource. There is no wasted or redundant 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?

With only one parameter, no output schema, and a simple getter operation, the description is adequate. It states it retrieves the current webhook configuration, which implicitly defines the return value. However, it does not elaborate on the structure of the configuration or edge cases. For this simplicity, the description is reasonably 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 schema description coverage is 100% for the single parameter 'appId' (with description 'App ID'). The description adds no additional meaning beyond the schema, 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 uses the specific verb 'Get' and resource 'webhook configuration for an app', clearly indicating a read operation. This distinguishes it from sibling tools like nolag_configure_webhooks (which implies modification/setup) and nolag_list_webhook_dlq (which focuses on dead-letter queue items).

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

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

The description implies the tool is for retrieving current configuration, but does not explicitly state when to use it over alternatives like nolag_configure_webhooks or nolag_list_webhook_dlq. The usage context is implied by the verb 'Get' rather than explicitly stated.

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

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

With no annotations provided, the description carries the full burden. It states the tool lists all actors, which implies a read-only operation, but does not disclose any potential limitations (e.g., pagination, ordering) or return format. It adds some context beyond the name ('all' and 'project') but lacks richer behavioral details.

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

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

One concise sentence that delivers the essential purpose without fluff. It is appropriately sized and front-loaded, 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 list tool with zero parameters, no annotations, and no output schema, the description is complete. It clearly defines the action (list), the scope (all actors), and the container (project). No additional context is necessary.

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 the baseline is 4. The description adds no parameter-specific information because there are none to explain. The schema already covers all parameters (none), so this is appropriate.

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

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

The description clearly states the tool lists all actors in the project, using a specific verb (list) and resource (actors). It distinguishes from sibling tools like nolag_get_actor (single actor) and nolag_list_scope_actors (actors within a scope) by specifying project-wide scope.

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

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

The description provides clear context — use when you need the full project actor list. It does not explicitly mention exclusions or alternatives, but the scope is unambiguous enough to guide selection. A more explicit 'for scoped lists, use nolag_list_scope_actors' would 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?

With no annotations, the description carries the burden. It explicitly says 'Query' and 'Returns', indicating a read-only operation, and mentions 'recent' and filterability. However, it does not disclose return format, ordering, pagination behavior, or potential side effects, leaving some behavioral gaps.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the action and resource, then adds key features (recent events, filtering) 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?

The description is adequate for a read-only list tool, but without an output schema, it leaves the agent guessing about the event structure. It also lacks details on event time window, ordering, or whether events are persisted. Overall, it provides the essentials but not full completeness for an observability tool.

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

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

The schema covers 100% of parameters with descriptions. The description merely reiterates 'filterable by severity and category' which aligns with schema properties but adds no extra semantic value beyond what the schema provides.

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

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

The description clearly states the tool's function: 'Query the agent event stream for a room' with a specific verb and resource. It distinguishes from sibling list tools by focusing on agent observability events, making it unique among the '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?

The description implies usage for retrieving observability events but does not explicitly state when to use it over alternatives or when not to use it. There is no mention of exclusions or contextual cues beyond 'recent observability events.'

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

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

No annotations are provided, so the description carries the burden. It adds the behavioral context that the app list is scoped by the API key, which is useful. However, it does not disclose pagination, return format, error behavior, or rate limits, so transparency remains limited.

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 with no wasted words. It conveys the action, resource, and scope 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 simple list operation with no parameters and no output schema, the description is adequate and complete. It states exactly what the tool does and its scoping. A minor gap could be mentioning the return format, but it is not critical for a list-all tool.

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

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

The tool has zero parameters, and the schema coverage is 100% (empty schema). According to the rubric, 0 params receives a baseline of 4. The description's mention of API key scope is authentication context, not a parameter.

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 ('List'), identifies the resource ('apps'), and clarifies the scope ('project determined by API key'). This clearly distinguishes it from sibling tools like get_app (single app) and create/update/delete app.

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 retrieving all apps, but it does not explicitly state when to use it vs alternatives like get_app, nor does it mention any exclusions or prerequisites. Usage 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?

With no annotations, the description is the only source of behavioral information. It states the operation is a listing, but does not disclose pagination, ordering, permission requirements, or return format. This is a minimal disclosure for a read operation.

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

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

Single sentence, no redundancy, directly states the action and scope.

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 with one parameter, the description covers the essential purpose. However, it doesn't mention return structure or any limitations; given no output schema, a bit more detail would help.

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 documents appId with description 'App ID' (100% coverage). The description adds context that the list is scoped by app, but this is largely implicit from the tool name and parameter name.

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

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

The description uses the specific verb 'List' and resource 'rooms', scoped by 'in an app'. It clearly distinguishes from sibling tools like get_room by implying collection vs single-item, though it doesn't explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives such as nolag_get_room or nolag_list_apps. The description only states what it does, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It mentions the selection criterion (assigned to a specific access scope) but does not explicitly state that it is read-only, safe, or how results are returned. The description is minimal and lacks depth beyond the core listing action.

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 tool's purpose. Every word contributes to clarity, and it is appropriately sized for such a simple 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 simple nature (one required parameter, no output schema, no annotations), the description covers the core purpose but leaves out expected return format and any edge-case behavior. It is adequate for basic understanding but not fully comprehensive.

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

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

The schema fully documents the only parameter 'scopeId' with a description ('Access scope ID'). The description adds little beyond the schema, and the schema coverage is 100%, 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?

The description clearly states the verb (list), resource (actors), and the limiting criterion (specific access scope). It differentiates from sibling tools like 'nolag_list_actors' which likely lists all actors without scope filtering.

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

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

Usage is implied by the scope filter, but the description does not explicitly state when to prefer this over alternatives or provide exclusions. An agent can infer it is for actors belonging to a specific scope, but no direct comparison to sibling tools is offered.

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

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

With no annotations, the description must carry the behavioral burden. 'List' implies a read-only operation, but the description does not explicitly disclose side effects, return format, or safety guarantees. For a simple zero-parameter list, this is minimally adequate but lacks depth.

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

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

The description is a single concise sentence that directly states the tool's purpose. There is no fluff or redundant information, making it highly efficient.

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

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

The description is adequately complete for a zero-parameter list tool: it states the action and target resource. However, since there is no output schema, it could have explicitly mentioned the return type (e.g., 'returns a list of scope objects'), but 'list all' sufficiently conveys the expected output for most agents.

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 and the schema has no properties, so description does not need to explain parameters. Per the rubric, a 0-parameter tool receives a baseline of 4.

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

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

The description 'List all access scopes in the project' clearly identifies the verb (list), resource (access scopes), and scope (project). It is distinct from sibling tools like get_scope (single vs all) and create/update/delete operations, making the purpose unambiguous.

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

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

The description implies the tool is for enumerating all scopes, contrasting with get_scope for a single scope, but it does not explicitly state when to use it versus alternatives or when not to use it. No exclusions are provided, but the guidance remains implicit.

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

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

With no annotations, the description carries the burden of transparency. It explains that the DLQ contains webhooks that failed after all retry attempts, which is useful behavioral context. However, it does not disclose that the status filter allows pending/dead entries, which may slightly conflict with the 'failed' phrasing, and does not mention return format or pagination beyond the schema.

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

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

The description is two sentences, with the primary action front-loaded and the clarifying definition in the second sentence. 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 simple list tool with two optional parameters and an output schema absent, the description is adequate. It clarifies the meaning of the DLQ and the origin of the entries. The only minor gap is the relationship between the status enum and the 'failed' wording, but this is handled by the schema.

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 does not need to explain parameters. It does not add additional meaning beyond the schema, which already documents limit and status defaults and enums.

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 lists failed webhook requests in the Dead Letter Queue, using the specific verb 'List' and the resource 'Dead Letter Queue'. It further clarifies what these webhooks are (failed after all retry attempts), distinguishing it from sibling tools like nolag_retry_webhook_dlq.

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 for when to use the tool: to inspect webhooks that failed after retries. It does not explicitly exclude alternatives or mention nolag_retry_webhook_dlq for retrying, so it lacks explicit when-not guidance, but the usage is well implied.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the action and does not mention side effects, persistence, permissions, return values, or whether it is fire-and-forget.

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 concise single sentence, front-loading the verb and object. It is appropriately sized, though it may be too sparse to convey important details, it does not waste words.

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

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

Given four required parameters and no output schema or annotations, the description is under-specified. It does not explain how the parameters relate, what a successful publish returns, or any behavioral context, making it incomplete for an agent to correctly invoke and understand the tool's effects.

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 full descriptions for all four parameters (data, appId, roomId, topic), so schema coverage is 100%. The description adds no additional parameter semantics, earning the baseline score 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 clearly states the tool publishes a message to a topic, using a specific verb and resource. It distinguishes from sibling tools like nolag_get_messages or nolag_dispatch_task, though it lacks context on app/room scoping.

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. The description does not mention any exclusions or context, such as differences from dispatching tasks, leaving the agent to infer usage from the tool name only.

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

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

No annotations are provided, so the description carries the full burden. 'Retry' implies a re-attempt, but side effects (state of DLQ entry after retry, idempotency, permission requirements, failure behavior) are not disclosed. This is a significant gap for a mutation tool.

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

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

A single clear sentence with no wasted words, instantly communicates the core 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?

With no annotations and no output schema, the description omits critical context: return value, side effects, prerequisites, and error conditions. The one-sentence description is too sparse for an agent to confidently invoke this tool.

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

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

The schema provides 100% coverage with a clear description for dlqId ('DLQ entry ID to retry'). The tool description adds no additional parameter semantics beyond this, so 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 uses a specific verb ('Retry'), names the resource ('failed webhook from the Dead Letter Queue'), and clearly distinguishes from sibling webhook tools like list or configure. It directly states the 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 usage when a webhook has failed and is in the DLQ, but provides no explicit when-to-use guidance, no exclusions, and no mention of the likely prerequisite of listing DLQ entries (nolag_list_webhook_dlq) to obtain the dlqId. It does not name alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the effect of isolation and the reset behavior of null, but lacks details on side effects (e.g., impact on existing communications, reversibility, permission requirements).

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the core action and covers the two key scenarios.

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

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

The tool is simple with 2 parameters and no output schema. The description covers the main use case and the unscope alternative. However, given the lack of annotations, it could provide more context on how the assignment affects communication and any prerequisites, but it is adequate for this complexity.

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 complete schema descriptions (100% coverage), making the input schema self-explanatory. The tool description mostly restates the scopeId null behavior already present in the schema, adding no additional semantic value beyond reinforcing the relationship.

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 'Assign' and the resource 'actor to a scope', distinguishing it from siblings as the only tool handling actor-scope assignment. The parenthetical 'isolates all communication' adds context, and the 'or set to null to unscope' clarifies both directions of the operation.

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

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

The description does not explicitly mention when to use this tool versus alternatives like create_actor or create_scope. It relies on the implied use case of assignment, with no explicit prerequisites, exclusions, or alternative tools mentioned.

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

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

The description only says 'Update an actor', which implies a write operation. It does not disclose partial vs full replacement semantics, side effects, required permissions, or response behavior. With no annotations, this leaves the agent with minimal safety or side-effect insight.

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

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

The three-word phrase is extremely brief but is under-specified for a tool with four parameters and update semantics. It resembles under-specification rather than purposeful concision, lacking any structural clarity or elaboration.

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

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

Given four parameters, no annotations, no output schema, and a mutation operation, the description is grossly inadequate. It does not explain update semantics, return values, or usage context, leaving the agent unguided for correct invocation.

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

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

Input schema covers 100% of parameters with descriptions, so baseline is 3. The description adds no additional meaning beyond the schema, not explaining how parameters interact or update behavior.

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

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

The description uses a specific verb ('update') and resource ('actor'), clearly stating the operation. It distinguishes from create/get/list/delete actor tools, though it does not add scope details that differentiate it further from other update_* 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?

No guidance is provided on when to use this tool versus alternatives like set_actor_scope or update_app. There are no context cues, prerequisites, or exclusions mentioned.

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

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

No annotations are provided, and the description gives no detail about side effects, partial vs. full update behavior, permissions required, or error conditions. It merely restates the action implied by the tool's name, providing no extra transparency.

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

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

The description is a single, extremely short sentence with no filler, and the key action is front-loaded. However, its brevity sacrifices useful context, though not enough to be penalized in this dimension.

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

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

Despite complete schema coverage, the description lacks any behavioral or contextual information. For a mutation tool with no annotations and no output schema, it should at least mention the required appId and the updatable fields. As is, it is inadequate for an agent to know how to invoke it correctly based on the description alone.

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?

Since all three parameters are documented in the schema (100% coverage), the description adds no additional parameter semantics. It doesn't mention that name and description are the updatable fields, but this is already in the schema, so 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 clearly states the action (update) and the resource (an app), distinguishing it from sibling tools like create_app, get_app, delete_app, and other update_ variants. However, it doesn't specify which attributes can be updated, making it slightly less informative than ideal.

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 alternatives, prerequisites (e.g., existing appId), or whether it should be used alongside other tools. The description is purely declarative without context.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It only says 'Update a room' and fails to mention whether updates are partial or full replacements, what happens to unspecified fields, idempotency, permissions, or side effects. This is a major gap for a mutation tool.

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

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

The description is extremely terse ('Update a room'), which is not the same as being appropriately concise. It under-specifies the tool's functionality and would benefit from at least one more sentence outlining the updatable attributes. It is not a waste of words, but it is under-dimensional.

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 has 5 parameters, no output schema, and no annotations. The description provides no context about return values, error conditions, or update semantics (e.g., PUT vs PATCH behavior). This makes it inadequate for an agent to fully understand the tool's effects and expectations.

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 of the 5 parameters has a meaningful description ('New room name', 'New room description', 'Whether the room is enabled', etc.). The tool description itself adds nothing about parameters, but that is acceptable given the schema's completeness. 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 clear verb+resource: 'Update a room'. This distinguishes it from other tools like nolag_create_room, nolag_get_room, and nolag_delete_room. However, it does not specify which fields can be updated or provide any additional scope, so it misses the top score.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as the room needing to exist, nor does it contrast with create or delete room operations. The context of sibling tools implies usage but the description itself provides no explicit direction.

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

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

The description discloses that the slug cannot be changed after creation, which is valuable behavioral context beyond the schema. However, it does not specify whether updates are partial or full, nor any error 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 short sentences with no filler. The statement about the slug is relevant and 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?

Given no annotations and no output schema, the description omits return format, potential errors, and update semantics. It is minimal but not misleading, yet more detail would be needed for full contextual 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?

All 5 parameters have schema descriptions (100% coverage), so the baseline is 3. The description adds a constraint about the slug (not in the schema), but does not elaborate on other parameter behaviors.

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 updates an access scope, with a specific verb and resource. It distinguishes itself from sibling tools like create_scope, delete_scope, and get_scope.

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

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

No explicit guidance on when to use this tool versus alternatives, though the name and sibling list imply it is for modifying existing scopes. No exclusions or alternative tools are mentioned.

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