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

With no annotations, the description details additive behavior for each mode, includes caveats about unresolvedScale tokens in compendium imports and sourcing restrictions, though it could mention permanent data modification more explicitly.

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

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

Well-structured with bullet points for modes, front-loads core purpose, but is somewhat lengthy due to complexity; could be slightly more concise without losing essential guidance.

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

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

Given the complexity (three modes, many parameters, no output schema), the description covers all necessary aspects including mode selection, parameter usage, sourcing rules, and caveats like unresolvedScale, making it comprehensive.

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

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

Schema coverage is 100% with detailed property descriptions; the description adds high-level organization and usage context but does not significantly enhance parameter meaning beyond the schema.

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

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

The description clearly states the tool adds features/spells/abilities to actors, outlines three distinct modes with clear explanations, and differentiates from sibling tools like add-item and import-item by explicitly recommending their use for gear.

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 explicit guidance on when to use each mode (compendium-features preferred for official content, feature for custom authoring, items only for free-form data) and references sibling tools for gear, along with instructions to find actorIdentifier using list-actors/get-actor.

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 discloses that the tool authors documents, does not roll/equip/spend charges, and intentionally allows duplicate names for stacks. It also mentions auto-replacement of invalid icon paths. However, it does not explicitly state required permissions or side effects like triggering updates.

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 long but well-organized with bullet points for item types and front-loaded purpose. Every sentence adds value, and the structure aids readability. Minor length justified by complexity.

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

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

Given the complexity (49 params, nested objects, many item types), the description is thorough. It explains each item type's fields, cross-cutting details, and distinguishes from siblings. However, it does not describe the return value (e.g., created item id), which is a minor gap since no output schema exists.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds high-level context about item types and cross-cutting fields but does not significantly augment individual parameter meanings beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool creates a structured physical item (loot/gear) on an actor or in the world Items sidebar, specifies it's for D&D 5e only, and distinguishes from siblings like add-feature and import-item by noting specific use cases.

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

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

The description provides explicit guidance on when to use this tool versus alternatives (add-feature for features/attacks-as-abilities, import-item for copying from compendium), and states what the tool does not do (no rolling, equipping, or spending charges). It also gives context for each itemType and cross-cutting behaviors.

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 discloses the default GM-only visibility and how to make it a handout, but does not explain error handling, return value, or side effects like image validation.

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 action, and contains no fluff. Every sentence adds value.

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

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

Without an output schema, the description should ideally mention return value or success confirmation. It does not. Given moderate complexity and good schema descriptions, the description is minimally complete but lacks closure on what the agent can expect back.

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

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

Schema coverage is 100%, baseline 3. The description adds context like 'Data-relative path' and 'defaults to file name' but largely duplicates schema descriptions. It does not significantly enhance parameter understanding beyond the schema.

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

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

The description clearly states the tool appends an image page to a journal entry, specifies the input (Data-relative image path) and optional caption, and distinguishes from siblings like create-journal or update-journal.

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 (append image to existing journal) and mentions GM-only vs. player-visible as a key consideration. However, it does not explicitly state when to prefer this over alternatives or what prerequisites exist (e.g., journal must exist).

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

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

With no annotations, the description carries full burden. It discloses that the tool authors condition state, is not an automation loop, and is D&D 5e only. It could mention permission requirements or reversibility, but overall transparency is good.

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

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

The description is concise with two sentences plus a brief note. It is front-loaded with the core purpose and then adds specifics in a logical order. Every sentence earns its place without redundancy.

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

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

Given the tool's complexity (4 params, no annotations, no output schema), the description covers purpose, usage, parameters, and system specificity. It could mention return behavior or effects on existing conditions, but remains fairly complete.

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

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

Schema coverage is 100%, but the description adds value: lists example conditions, explains exhaustionLevel semantics, and notes that actorIdentifier can accept a token ID for instance-specific application. This goes beyond the schema definitions.

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

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

The description clearly states the tool applies or removes conditions on an actor, listing specific condition examples. It distinguishes itself from siblings by explicitly noting it is not a combat-automation loop, which sets it apart from potential automation tools.

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

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

The description provides clear guidance on how to use: system-specific (D&D 5e), toggling with active boolean, exhaustion level handling, and how to find the actor identifier. While it doesn't explicitly list alternatives for similar tasks, the context is sufficient for correct usage.

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

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

With no annotations provided, the description is the sole source of behavioral details. It states read-only nature (Plane B, file channel, read-only) and lists returned attributes. However, it does not address error states (e.g., path not found) or behavior for directories beyond 'for files' note, 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 extremely concise: two short sentences that front-load the core purpose and usage context. Every phrase earns its place with no redundancy.

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

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

Given the tool's simplicity (1 parameter, no output schema, basic annotations), the description is largely complete. It explains what the tool returns, when to use it, and the read-only nature. Minor gaps (error handling, directory behavior) prevent a perfect score.

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

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

Schema description coverage is 100%, and the input schema already fully describes the parameter including the relative path root. The tool description adds no new meaning beyond the schema, so 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 clearly states the tool's purpose: checking existence and retrieving metadata for a single path under Foundry's Data/ root. It distinguishes from siblings like list-assets by emphasizing it's a cheap, single-path check before uploads or linking.

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 includes explicit guidance: 'A cheap existence/metadata check before uploading or linking.' This tells the agent when to use it, but does not explicitly list when not to use it or mention alternative tools.

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

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

The description explicitly states 'Pure mapping (no network)', indicating no side effects or network calls. This transparency is crucial as no annotations are provided. The behavior is fully disclosed without contradictions.

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

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

Three concise sentences: introduction, mapping explanation, and use case. No redundant information; every sentence adds value.

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

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

For a simple tool with one parameter, no output schema, and no annotations, the description is fully complete. It covers functionality, behavior, input format, and usage context.

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

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

The schema has 100% coverage for the single parameter 'remotePath', describing its format. The description adds minimal extra value by mentioning the mapping rule, but it largely repeats schema content, 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 verb 'return' and the resource 'public HTTPS URL for a file under the Foundry Data/ root'. It distinguishes from siblings by specifying it is a pure mapping (no network call) for generating URLs, contrasting with tools like download-asset.

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 converting asset paths to loadable links (e.g., 'Useful for turning an uploaded/known asset path into a link Foundry or a player can load'), but it does not explicitly compare with alternatives or state when not to use. No exclusions are provided.

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

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

With no annotations, the description carries full burden. It clearly implies creation of a new actor, lists required and optional parameters, and suggests follow-up actions (add-feature, import-item). It doesn't explicitly state side effects or authorization needs, but the creation context is clear and non-destructive.

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

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

The description is front-loaded with purpose and usage guidelines, then lists required and optional params. It is somewhat lengthy due to comprehensive parameter coverage, but every sentence adds value. Could be slightly more concise without losing 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 35 parameters, no output schema, and no annotations, the description addresses the core purpose, usage context, all required params, and many optional ones. It also provides post-creation guidance (add-feature, import-item). Missing return value description, but the creation context makes that less critical.

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

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

Schema description coverage is 0%, but the description extensively explains each parameter's meaning and usage. It provides examples (e.g., cr as number or fraction), clarifies default behaviors (e.g., disposition default 'hostile'), and links parameters to game concepts (e.g., 'friendly for allies/townsfolk'). This adds significant value beyond the schema.

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

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

The description clearly states the tool authors a custom NPC from a stat block, specifies it's a last-resort path, and distinguishes from compendium-based creation. The verb 'author' and resource 'custom NPC' are precise, and the 'LAST-RESORT' label immediately clarifies its role.

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

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

Explicitly states when to use ('used ONLY when nothing in the premium MM/PHB/DMG books is a workable base'), when not to use (prefer create-actor-from-compendium), and provides explicit guidance to ask the user before authoring. Also recommends 2024 ruleset and lists required fields.

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?

Highlights permanence, irreversibility, strict resolution, and GM-only requirement. Without annotations, the description fully compensates with critical 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?

Three succinct sentences, front-loaded with key information. Every sentence adds value with no waste.

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

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

No output schema, but description explains what is deleted, irreversibility, and how to preview. Covers all necessary context for a bulk delete tool.

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

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

Schema coverage is 100%. The description adds context beyond schema: 'exact id or name' for identifiers, 'single type' for documentType, and dry-run recommendation. One point above baseline due to helpful extra detail.

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 deletes many world documents by exact ID or name, specifying strict resolution and a single type. It distinguishes from sibling 'delete-folder'.

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

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

Explicitly suggests using dryRun first, directs to delete-folder for folders, and notes GM-only restriction, providing clear when-to-use guidance.

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

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

The description explicitly states 'read-only; never mutates', which is essential for behavioral transparency. However, it does not mention potential side effects like processing time or network usage, though the tool is relatively simple.

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

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

The description is well-structured with numbered rules and clear sections. It is front-loaded with the core purpose and read-only assurance. While somewhat lengthy, the details are necessary for the tool's complexity.

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

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

The description explains what the tool does and what to do after, but it does not specify the format of the output report (e.g., list of violations). Given the complexity and absence of an output schema, more detail would be beneficial.

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 described with context beyond the schema, explaining how they are used in the audit (e.g., actorIdentifiers scan actors and their embedded items). The default behavior when no parameters are given is also clarified.

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

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

The description clearly identifies the tool as a finishing check for D&D 5e content, scanning for four specific authoring-quality rules. It distinguishes itself from sibling tools by being read-only and audit-focused.

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

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

It explicitly states when to run (before declaring a build done), how to target specific entities (actorIdentifiers, itemFolders, worldItemIds), and what to do after (fix and re-run). This provides clear 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 provided, so the description carries the burden. It discloses automatic parent folder creation, no effect on references, and path restrictions. It also signals it is a write operation ('Plane B (file channel, write)'). Could be improved by mentioning error handling for overwrite=false.

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 plus a parenthetical and requirement note. It is front-loaded with key context ('Plane B (file channel, write)') and every sentence adds essential information without redundancy.

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

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

Given no output schema and 3 parameters, the description covers core behavior well. It lacks details on whether folders can be copied (only files are implied). Also does not specify return value. However, it is fairly complete for a file copy 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?

Schema coverage is 100%, baseline 3. The description adds value by explaining that missing destination parent folders are created automatically (relevant to toPath). This goes beyond the schema's description. No additional info for fromPath or overwrite, but sufficient.

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 copies a file under Foundry's Data/ root. It specifies the file channel (Plane B write), mentions automatic parent folder creation, and distinguishes from world-DB operations. The verb 'Copy' and resource 'file under Data/ root' are specific and unambiguous.

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

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

The description implicitly tells when to use (to copy files within Data/ root) and includes important constraints (refuses live world-DB paths, requires MOLTEN_WEBDAV_PASSWORD). It does not explicitly name alternatives like move-asset, but the context of copying vs moving is clear.

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

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

In the absence of annotations, the description discloses key behaviors: edits apply only to the world copy, not the source; modifications affect all copies when quantity > 1; placement and disposition defaults are explained. However, it could mention potential rate limits or permission requirements, but covers essential mutation behavior thoroughly.

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, dense paragraph that front-loads the core purpose. It uses bold for key terms but could benefit from bullet points or section breaks for readability. Despite length, every sentence adds necessary detail; no redundancy.

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

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

Given 8 parameters with nested objects, no output schema, and multiple use cases (simple copy vs. prefab-as-base), the description fully covers both paths and references sibling tools (search-compendium, update-actor, author-npc). Provides enough context for an agent to correctly decide usage and invocation.

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

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

Schema coverage is 100%, providing baseline 3. The description adds substantial meaning: packId restricted to premium books, names shown with examples, modifications detailed with the update-actor shape, disposition with authoring policy, placement with coordinates requirement. This significantly aids parameter understanding beyond schema.

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

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

The description clearly identifies the tool as copying actors from premium-book compendium packs, distinguishing it as the default path for official content and contrasting with author-npc for hand-authored NPCs. It specifies the action (copy), source (compendium), and key variant (prefab-as-base with modifications).

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

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

Explicitly instructs to first find the entry via search-compendium/get-compendium-entry and then pass packId, itemId, and names. Provides clear alternatives: use author-npc for no compendium base, and explains the modifications parameter for the prefab-as-base bridge. Also gives disposition default rules.

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?

Discloses idempotency, requirement for MOLTEN_WEBDAV_PASSWORD, refusal of live world DB paths, and creation of missing parents. Lacks details on return values or error responses, but overall sufficient given no annotations.

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

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

Two concise sentences plus a requirement note, all front-loaded with key identifiers ('Plane B'). 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?

Covers idempotency, constraints, and requirement. The 'Plane B' term is unexplained, and no output description is given, but for a simple creation tool with no output schema, it is fairly 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 single parameter 'remotePath' is described in schema with an example, and the description adds that missing parents are created. This exceeds the schema alone. No further parameter details needed.

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

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

The description clearly states the tool creates a folder under Foundry's Data/ root over WebDAV, is idempotent, and has specific constraints (refuses live world DB paths). It distinguishes itself from sibling tools like 'create-folder' by specifying the 'Plane B (file channel, write)' context.

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

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

Provides clear context: use for creating folders via WebDAV, idempotent, and warns against live world DB paths. However, no explicit comparison to similar sibling tools (e.g., 'create-folder') is given.

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 discloses GM-only permission requirement, the optional folder creation, and the structure of cards (face text/img vs plain). This is good behavioral coverage for a creation 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?

Two sentences with key information front-loaded. First sentence covers primary action and scope; second adds card structure; third provides use cases and permission. 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?

Given 5 parameters, high schema coverage, and no output schema, the description sufficiently covers creation behavior, card structure, and use cases. It lacks error/edge-case details but is adequate 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%, baseline 3. The description adds value by explaining `text` as HTML shown on the card, `img` as Data-relative path, `description` as GM/meta note, and `folderName` behavior. This context is beyond the schema descriptions.

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

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

The description clearly states it creates a Cards stack (deck, hand, or pile) with optional initial cards, specifying the verb and resource. It distinguishes from siblings like list-cards, delete-cards, and import-cards by focusing on creation for custom themed decks.

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 advises use for custom themed decks and notes GM-only, providing clear context. It does not explicitly exclude other scenarios, but the sibling set is large and the purpose is well-defined.

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 fully discloses behavioral traits: it creates drawings, supports per-drawing error isolation, returns created IDs, and is GM-only. It explains default stroke behavior and flags like hidden/interface. No contradictions.

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

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

The description is moderately concise given the complexity; it front-loads the purpose and covers key parameters efficiently. A minor reduction in verbosity could improve clarity, but it is well-structured.

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

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

The description covers usage, parameter details, behavior (error isolation, GM-only), and return value (created ids). For a tool with many parameters and no output schema, it is remarkably complete.

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

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

Schema coverage is 100%, and the description adds value by explaining the coordinate origin (top-left absolute), shape type specifics, and default styles (e.g., 'default stroke makes a bare shape visible'). This enriches the schema definitions.

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

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

The description clearly states it places DRAWINGS (GM annotation shapes) on a scene, enumerating shape types, coordinate system, styling options, and special flags. It distinguishes itself from siblings like create-tiles or create-lights by specifying the exact use case (secret-area boxes, trap outlines, zone labels).

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 GM-only annotations and mentions per-drawing error isolation, but does not explicitly state when to use this tool over alternatives like create-tiles or create-lights. The context of sibling tools is not directly addressed.

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 provided, so description carries full burden. It discloses GM-only permission, creation of sidebar folders, and nesting constraint. Does not detail error handling or side effects, but for a simple create operation this is sufficient.

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

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

Two concise sentences with no filler. Purpose is front-loaded, critical details (nesting, GM-only) are included. 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?

Simple tool with no output schema. Description covers what it creates, how it can be used (nested, for organizing), and who can use it. Sufficient for an agent to select and invoke correctly.

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

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

Schema coverage is 100% with descriptions for all 4 parameters. Description reinforces nesting constraint for parentFolder but adds no new meaning for other parameters like color. Baseline 3 is appropriate.

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

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

Description explicitly states it creates sidebar folders for any world document type, with optional nesting. It distinguishes from create-* siblings (which create documents) and includes usage context ('organize generated content') and visibility ('GM-only').

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?

States 'organize generated content' and 'GM-only', providing clear context. However, it does not explicitly say when not to use or mention alternatives (e.g., deleting folders via delete-folder). Still, the sibling list implies the tool is for folders 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?

With no annotations, the description discloses key behaviors: world-level creation, GM-only access, preference for 2024 data model, and the role of the 'system' field. Lacks details on failure modes or duplicate handling, but covers essential aspects.

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?

Multi-sentence but efficient; front-loads the core action then provides alternative guidance. Every sentence serves a purpose, though could be slightly more concise.

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

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

For a tool with 2 parameters and no output schema, the description covers creation scope, target audience, data model preference, and alternatives. No significant gaps.

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

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

Schema coverage is 100% and the description adds meaningful context: explaining the purpose of the 'system' field, noting valid types, and setting usage scope. Adds value beyond the schema.

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

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

Clearly states the verb 'Create', the resource 'world-level Item document(s) in the Items sidebar', and enumerates the types of reusable library items. Distinguishes from sibling tools by listing alternatives for actor-level operations.

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

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

Explicitly states it is GM-only and provides clear guidance on when not to use it ('To put items on an actor instead...') with named alternatives (import-item, add-item, add-feature).

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 provided, so description carries full burden. It explains behavioral traits like GM-only default, page visibility (playerVisible), folder creation, and page types. However, it does not mention idempotency or error conditions, but overall provides good context beyond 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?

Four sentences, front-loaded with purpose, then details page types, differentiates from sibling, and covers folder and visibility. Every sentence adds value; no 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 no output schema and high schema coverage, description covers key aspects: creation of journal, page types, folder option, and visibility. It misses explicit mention of default page kind (text) and return value, but is complete enough for a creation tool with good parameter documentation.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by explaining the distinction between text and image pages, the requirement of src for images, the optional caption, and the meaning of playerVisible. This goes beyond schema descriptions.

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

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

Description clearly states it creates a multi-page JournalEntry from supplied pages. It distinguishes from sibling 'create-quest-journal' by noting it takes explicit pages and only folders when folderName is given. The verb and resource are specific.

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

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

Explicitly contrasts with sibling tool 'create-quest-journal', stating that this tool is for generic journals with explicit pages, while the sibling has styled blocks and auto-folders. This gives clear when-to-use guidance.

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

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

With no annotations provided, the description fully discloses behavioral traits: units for x/y and radii, darkness activation range, walls/vision effects, per-light error isolation, return of created ids, and GM-only restriction. It adds context beyond the schema, such as 'NOT pixels' and 'torch only lights once the scene dims'.

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 paragraph of moderate length (approx. 100 words) that front-loads purpose and then details parameters. It is packed with information but remains readable; however, it could be slightly more structured (e.g., bullet points) for even easier scanning.

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

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

Given the complexity (nested array, many optional parameters, no output schema), the description covers main behaviors, parameters, and outcomes (returns created ids). It mentions per-light error isolation but could elaborate on what that entails. Overall, it is fairly complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds extra meaning beyond the schema: clarifies units for dim/bright (grid-distance units, NOT pixels), gives examples for animationType (torch, flame, pulse), and mentions default values (alpha ~0.3, luminosity 0.5, darknessMin ~0.1). This adds significant value.

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

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

The description clearly states the verb 'Place' and the resource 'AMBIENT LIGHTS', with specific examples (torches, braziers, magical glows). It distinguishes from sibling tools like create-drawings or create-tiles by focusing exclusively on light sources, and notes it is GM-only.

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 implicitly indicates usage for placing ambient lights on a scene. However, it does not explicitly state when not to use or provide alternatives, relying on the sibling list for distinction. This is clear but lacks explicit 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, the description fully discloses behavior: it runs real advancement, does not persist on failure (success:false with errors), returns detailed output fields, and explains the dry-run behavior. It also clarifies that ASI ability-increases are expected final and feats are not added by this tool, ensuring no surprises.

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 long but well-structured, with front-loaded main purpose and progressive details. Every sentence adds value, covering all key aspects. Minor verbosity is justified by the tool's complexity, but it could be slightly more terse without losing clarity.

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

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

Given the complexity (13 parameters, nested objects, multiclass, dry-run, error handling) and no output schema, the description is fully complete. It explains the return value structure, the multi-step workflow, edge cases like missing class or failed advancements, and provides enough detail for an AI agent to use the tool correctly.

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

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

Despite 0% schema description coverage, the description explains the purpose and usage of most parameters: name, className, level, abilities (final scores), choices (with structure), multiclass, spells, hpMode, sourceRules, acceptDefaults. It adds critical context like 'abilities must be final' and 'choices map format', compensating fully for the missing schema descriptions.

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

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

The description clearly states it builds a player character headlessly using premium compendium content, with real dnd5e advancement and native scale feature resolution. It distinguishes itself from NPCs and sibling tools like 'create-pc-from-prefab' and 'level-up-pc' by detailing its specific functionality, such as dry-run mode and multiclass support.

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 extensive usage guidance: it explains the two-step process (dry-run then fill choices), what inputs to provide (final abilities, choices map, multiclass array), and what not to include (gear, ASI-feats). It also specifies constraints like premium books only and error handling. However, it doesn't explicitly compare with sibling tools or say when to choose this over alternatives.

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

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

With no annotations, the description fully bears the burden of behavioral disclosure. It reveals that the tool copies the source (never modifies the original), applies modifications to the copy, resolves @scale natively, and does not set ownership (requires a separate step). It also specifies the return shape. This is a complete and honest description of the tool's behavior.

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

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

The description is moderately concise at around 150 words, packing essential information without significant fluff. It is well-structured: purpose first, then method, resolution, overrides, behavioral notes, and returns. However, some sentences are long and dense, which slightly reduces readability. Minor improvements could make it more streamlined.

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

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

Given the complexity (7 parameters, nested objects, no output schema, no annotations), the description is quite comprehensive. It covers the core workflow, constraints (premium only), resolution options, and return structure. The main gaps are the lack of explanation for the 'folder' parameter and the exact shape of 'modifications'. Still, it provides enough context for correct usage.

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

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

Despite 0% schema description coverage, the description adds substantial meaning to several parameters: it explains how 'prefab' resolves (by name or explicit packId+actorId), what 'abilities' expects (array of final scores), and what 'modifications' are (update-actor-shaped updates applied to copy). 'folder' and other basic parameters are not elaborated, but the critical ones are covered. It compensates well for the lack of schema documentation.

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

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

The description clearly states the tool's purpose: creating a player character by copying a premium-book pregen template. It uses specific verbs ('Create', 'COPYING', 'layering'), identifies the resource (premium-book PREGEN), and distinguishes this approach from building via advancement. It also contrasts with create-actor-from-compendium for NPCs, 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 explicitly tells when to use this tool: for creating a PC from a pregen template instead of advancement. It provides guidance on source resolution (by prefab name or packId+actorId), specifies that premium books only are allowed (never SRD), and mentions a follow-up step (set-actor-ownership). It also implies when not to use it (if not using a pregen or using SRD). This is comprehensive.

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 provided, so description carries full burden. Mentions creation and modes, but lacks details on side effects, error handling, or dependencies (e.g., valid paths). Adequate but not comprehensive.

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

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

Two concise sentences; first states purpose, second adds modes and restrictions. No redundant information, front-loaded.

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

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

No output schema, so expected return value (created playlist) is not described. Lacks error conditions or prerequisites. Adequate for a creation tool but could be more complete.

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

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

Schema coverage is 100%, baseline 3. Description adds context for soundPaths (data-relative paths) and lists modes, enhancing understanding beyond schema descriptions.

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

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

Clearly states 'Create a Foundry Playlist from a list of Data-relative sound paths' with specific verb and resource. Distinguishes from sibling tools like update-playlist and delete-playlist.

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

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

Explicitly states 'GM-only' for authorization and references typical use case with upload-asset. Could be more explicit about when not to use vs update-playlist, but implied by the create verb.

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

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

The description discloses key behaviors: it never writes the prose, renders in house style, sets per-page visibility. Without annotations, it provides good transparency, though could include details on error handling or limits.

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

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

The description is well-structured and front-loaded with key information, but slightly verbose in listing block types; still clear and 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?

Given the tool's complexity (multi-page journal with multiple block types), the description covers purpose, usage, block types, visibility, and alternative tool, making it fully complete.

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

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

Schema coverage is 100%, and the description adds value by summarizing the block types, explaining the structuring role, and clarifying visibility vs schema descriptions.

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

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

The description clearly states the tool creates a multi-page journal from structured typed blocks, and distinguishes it from the sibling tool 'create-journal' which handles plain raw-HTML pages.

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

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

The description explicitly says when to use this tool (for structured blocks) and when not to, providing the alternative 'create-journal' for plain raw-HTML pages.

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 provided, so description carries full burden. It discloses that behaviors pass through verbatim, teleportToken requirements, and returns created region ids. Lacks mention of error behavior or idempotency, but overall strong.

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?

Compact single paragraph, front-loaded with key info (verb, constraint, sibling relationship). Every sentence adds value; no redundancy.

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

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

For a 2-param tool with no output schema, description covers input requirements (scene must exist), shapes format, behaviors caution, and return value. No obvious gaps.

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

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

Schema coverage is 100%, but description adds value: clarifies shapes are in canvas px with type examples, explains visibility values, and adds behavior constraints beyond schema. Not perfect, but adds meaningful context.

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

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

Clearly states verb 'Create', resource 'Regions', and context 'on an EXISTING scene'. Distinguishes from sibling 'create-teleporter' by noting it is the general primitive behind it.

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

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

Explicitly says 'GM-only' and recommends using 'create-teleporter' for the two-new-region convenience, providing clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description details behavioral traits: SRD refs are refused, premium items render as @UUID links, ranges auto-assign, formula defaults to 1d<total weight>. It also notes GM-only. However, it misses potential side effects like permission requirements or overwrite behavior.

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

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

The description is a single paragraph that packs essential information concisely. It is front-loaded but could benefit from more structured formatting like bullet points. It is effective without being overly verbose.

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

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

The description covers purpose, parameters, and key behavior, but lacks information about the return value (e.g., what is returned after creation). Given no output schema, this is a gap. Otherwise, it is reasonably complete for the 7 parameters.

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

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

Schema coverage is 100%, but the description adds value by explaining how results combine text and uuid, the auto-assignment of ranges, and the default formula. This goes beyond the schema descriptions, earning a 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 clearly states the tool creates a RollTable from a list of results, specifies the types of results (text/UUID), mentions auto-assignment of ranges and formula, and distinguishes it from siblings like import-rolltable and roll-on-table.

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 says 'Use for random encounter/loot/rumour/treasure tables. GM-only.' It provides clear use cases and access restrictions, but does not explicitly mention when not to use or alternatives beyond the implicit 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, the description fully discloses behaviors: auto-detection of dimensions, auto-generation of thumbnail, folder creation, navigation setting, and import capabilities. It also notes limitations like Foundry regenerating thumbnails and MCP response cap for placeablesPath.

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

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

The description is front-loaded with the main purpose and structured logically. However, it is somewhat verbose with multiple clauses and parentheticals, which could be tightened. Every sentence adds value, but conciseness could be improved.

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

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

For a complex tool with 30 parameters, the description covers most aspects: main use, options, edge cases (auto-detect, auto-thumb), best practices, and limitations. It lacks a clear statement about what the tool returns (e.g., the created scene object), but overall is highly 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 already has 100% description coverage, so baseline is 3, but the description adds significant extra meaning: context on auto-detection, auto-generation, preferring config objects for lights, deep-merging of flags/environment, and server-side reading of placeablesPath. This goes well beyond the schema.

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

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

The description begins with a clear verb and resource: 'Create a Foundry Scene from a Data-relative background image path'. It specifies the unique input method and distinguishes itself from sibling creation tools by covering all scene creation aspects in one call.

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 on when to use this tool, including options like auto-detect, auto-generated thumbnails, importing walls/lights, and setting navigation. It implies comprehensive scene setup but does not explicitly state when not to use it or mention 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 fully carries the burden of behavioral disclosure. It explains deterministic behavior, error isolation per note, that GM-only secrecy is from journal ownership not the pin, and that 'global' only controls fog occlusion. It also states the return value (each created note id). No contradictions.

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

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

The description is a single paragraph that front-loads the main purpose and then provides essential details. Every sentence adds value. It is concise but could be slightly better organized (e.g., separate sections for usage, behavior, return). Still, it is efficient.

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

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

Given no annotations, no output schema, and nested input (notes array), the description covers purpose, parameters, error handling, and return. It is mostly complete, though it lacks details on error behavior for unresolved scene identifiers. Overall, it provides sufficient context for an AI agent.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaningful context beyond the schema, such as referencing 'get-scene-dimensions' for padding-aware math and clarifying the 'global' parameter's role. This enhances understanding.

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

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

The description clearly states the action ('Place map-note PINS on a scene') and the resource (linked to a JournalEntry), and distinguishes it from siblings by calling it 'the deterministic half of the legend→GM-room-pins feature'. It is specific and informative.

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 on how to use the tool, including guidance on x/y coordinates referencing 'get-scene-dimensions', per-note error isolation, and the meaning of the 'global' parameter. However, it does not explicitly mention when not to use this tool or suggest 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 fully discloses behavioral traits: x/y are absolute canvas pixels, radius is in grid-distance units, optional parameters like walls (muffle through walls), easing (fade by distance), darkness activation range (night-only sounds), listener effects (baseEffect/muffledEffect), and that a 404 path warns but keeps. It also states the return behavior ('Returns created ids').

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 paragraph that is both comprehensive and concise. It front-loads the main purpose and example, then covers essential details without unnecessary fluff. Every sentence adds value.

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

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

Given the tool's complexity (many optional parameters, nested array input, no output schema), the description covers all critical aspects: input structure, key unit distinctions, behavior of each option, and return value. It is complete without needing an output 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 coverage is 100%, but the description adds significant meaning beyond the schema: clarifies units for radius (grid-distance vs. pixels), explains the purpose of walls, easing, darknessMin/darknessMax, baseEffect/muffledEffect, and default values (volume 0.5, repeat false). This enriches the agent's 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 'Place one or more positional AMBIENT SOUNDS on a scene' and provides concrete examples (crackling hearth, waterfall). It distinguishes from a sibling tool by noting 'Distinct from a scene playlist: this is a point emitter players walk into.' This leaves no ambiguity about the tool's purpose.

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

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

The description explicitly marks the tool as 'GM-only' and mentions that a 404 audio path 'keeps the path but warns'. It contrasts with scene playlist implicitly, but does not provide extensive when-to-use/when-not-to-use guidance. Still, the context is clear enough for an agent to decide.

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 provides important behavioral details: trigger rectangles are placed, grid-snapped by default, regions default to GM-only visibility, and the order of operations. It does not mention permissions or potential side effects, but covers most key behaviors.

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 somewhat lengthy but each sentence adds useful information. It is structured logically: purpose, then mechanics, then details. No wasted words, though it could be slightly more compact without losing clarity.

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

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

Given the complexity (9 parameters, nested objects, no output schema), the description covers purpose and behavior well but does not mention what the tool returns (e.g., region IDs or status). For a tool with no output schema, this is a notable gap, leaving the agent unsure of the response format.

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, so baseline is 3. The description adds value by explaining the overall concept of two-way vs one-way and the triggering mechanism, which goes beyond the parameter descriptions. It also mentions grid-snapping and GM visibility, which are behavioral but supplement parameter understanding.

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

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

The description clearly states the tool creates a region teleporter between two points on existing scenes, distinguishing it from create-scene which only does this at import time. It specifies the verb 'create' and resource 'teleporter' with clear 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 explains when to use: for creating teleporters on existing scenes, and mentions that it handles the chicken-and-egg problem by creating both regions before linking. It doesn't explicitly state when not to use or compare to sibling tools like remap-teleporters, but the context 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?

With no annotations, the description is the sole source of behavioral info. It discloses per-tile error isolation, 404 warnings, return of created IDs, and GM-only restriction. It also explains occlusion mode semantics, adding useful 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 dense single paragraph that front-loads the main purpose and then details parameters. It is efficient, though it could be slightly more structured for easier scanning.

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

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

Given the complexity (many optional parameters, nested objects, no output schema), the description covers essential behavior, return value, and error handling. It is sufficient for an agent to understand usage without additional info.

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%, but the description adds context beyond parameter descriptions, e.g., clarifying that width/height are canvas pixels and referencing get-scene-dimensions for coordinate math. It explains occlusionMode values and video behavior, enhancing schema.

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

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

The description specifies the tool places TILES (props, roof pieces, decals, video overlays) on a scene from Data-relative image paths, clearly distinguishing it from siblings like create-drawings or create-lights.

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 correctly indicates GM-only usage and lists tile types, but does not explicitly state when to avoid this tool or mention alternatives. The context of sibling tools implies its specific role, but guidance is implicit.

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

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

With no annotations provided, the description discloses key behaviors: per-wall error isolation, returns created ids, GM-only access. Also details default channel blocking behavior ('omitted channels default to 20 blocking'). No mention of rate limits or auth beyond GM-only, but adequate.

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 dense paragraph but well-structured: starts with purpose, then coordinate/segment spec, then channels with defaults, then per-wall isolation and return. No wasted words, but could benefit from bullet points for readability.

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

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

Given the tool's complexity (2 parameters, one being an array of objects with many properties, no output schema), the description covers coordinate alternatives, channel defaults, door types, per-wall error isolation, and return value. It lacks output schema details but none is provided. Adequate for a complex mutation tool.

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

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

Schema coverage is 100%, and the description adds meaning beyond the schema: explains coordinate system ('absolute canvas pixels'), summarizes channel type options and defaults, clarifies door state values, and notes that 'omitted channels default to blocking'. This aids understanding beyond raw schema.

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

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

The description clearly states it creates WALL segments on a scene, specifying 'surgical additions' to existing walls. It distinguishes from walls 'normally drawn in the app or shipped by a map pack', and contrasts with sibling tools like 'update-walls' and 'delete-walls'.

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

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

Provides clear context: 'surgical additions (block a corridor, add a door/secret door)' to existing walls. Sibling tools don't create walls, so usage is implied. No explicit when-not-to-use or alternatives, but the context is sufficient.

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, description fully discloses key behaviors: irreversibility, GM-only requirement, strict matching (no fuzzy), and auto-removal of bridge-created empty folders. No contradictions.

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

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

Single paragraph with three sentences, front-loaded with main action. Every sentence adds value; no fluff. Efficiently covers critical details.

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

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

For a destructive delete tool with no output schema, description covers all essential aspects: action, resolution, prerequisites, permissions, and side effects (folder removal). Complete given 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?

Schema coverage is 100%, baseline 3. Description adds meaning: explains 'identifiers' as exact names/IDs and strict resolution, and clarifies 'removeEmptyFolder' only affects bridge-created empty folders. Adds value beyond schema.

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

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

Description clearly states 'Permanently delete one or more world actors (NPCs/characters) by exact name or ID.' It uses specific verb (delete) and resource (actors), and distinguishes from sibling tools that delete other types (e.g., delete-asset).

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

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

Description advises looking up precise name/ID with list-actors first and notes GM-only access. It implies caution due to irreversibility, but does not explicitly state when not to use or alternatives like bulk-delete for multiple actors.

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 fully discloses behavior: consults find-asset-references, refuses if references exist, requires recursive for directories, and refuses live world-DB paths. It lacks explicit error handling or success output 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?

Five focused sentences with no fluff, each conveying key information. Slightly dense but efficient; could be reordered for better flow.

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

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

Covers purpose, prerequisites, key behaviors, and parameter usage. Missing details on return value or confirmation of success, but given the tool's simplicity and lack of output schema, it is adequately complete.

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

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

Schema descriptions are 100% covered, but the tool description adds extra context for `force` (overrides reference check failure) and `recursive` (required for directories), enhancing understanding beyond the schema.

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

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

The description clearly states 'Delete a file under the Foundry `Data/` root over WebDAV,' providing a specific verb and resource. It distinguishes from sibling delete tools (e.g., delete-actor, delete-scene) by targeting file assets.

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

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

Explicitly describes when to use (with reference-awareness and directory deletion requirements), when not to use (refuses live world-DB paths), and alternatives (pass force:true to override). Also notes required password.

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 adequately discloses behavioral traits: permanent deletion, strict exact matching, and GM-only permission requirement. It covers the key aspects of how the tool behaves, though it could mention if deletion is reversible or affects related data.

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

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

The description is a single sentence conveying all essential information: action, resource, matching constraint, and permission requirement. No redundant or unnecessary words.

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

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

Given the tool's simplicity (one parameter, no output schema, no nested objects), the description covers the necessary context: what it does, how to use it (exact match), and who can use it (GM). It could mention if it only deletes stacks, not individual cards, but 'Cards stacks' implies that.

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

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

The schema covers 100% of the parameter with a description. The description adds 'STRICT resolution' which reinforces the schema's 'exact' qualifier, but provides little additional meaning beyond what the schema already states. Baseline 3 is appropriate.

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

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

The description clearly states the tool permanently deletes Cards stacks by exact id or exact name. It specifies the resource ('Cards stacks') and the action ('permanently delete'), distinguishing it from other delete tools like delete-folder or delete-actor. The mention of 'GM-only' adds an important constraint.

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 guidelines: use exact ids or names, no fuzzy/substring matching, and the tool is GM-only. However, it does not explicitly mention when to use this tool over other deletion tools or alternatives like list-cards to find exact names.

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 explicitly states the operation is IRREVERSIBLE and GM-only, and explains the confirm guard for bulk modes. This covers the key behavioral traits beyond what the schema provides.

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

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

The description is concise—three short sentences covering all modes, constraints, and key warnings. Every sentence adds value, with no fluff or redundancy. The most critical information (IRREVERSIBLE, GM-only) is highlighted.

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

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

For a tool with no output schema and 4 parameters, the description provides complete context: all deletion modes, parameter relationships, confirm guard, and usage restrictions. It also includes a real-world performance hint. No gaps remain for an agent to safely 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?

Schema coverage is 100%, but the description adds significant meaning by explaining how parameters combine into three usage patterns (ids, beforeTimestamp+confirm, clearAll+confirm) and provides a performance-related use case for beforeTimestamp. This enhances understanding beyond the schema descriptions.

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

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

The description clearly states the verb 'Delete' and resource 'chat messages', and distinguishes three distinct deletion modes (by ids, before timestamp, clear all). This differentiates it from sibling tools like list-chat-messages and export-chat-log.

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 to use each mode, including the requirement for confirm:true in bulk operations. It provides a specific use case ('handy for the known Molten big-log perf drag'). However, it does not explicitly compare with sibling delete tools for other resources, though the name makes it clear.

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

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

No annotations provided, so description carries full burden. It discloses id source, non-fatal error handling for missing ids, and GM-only restriction. This is comprehensive for a delete 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?

Two short sentences, no redundancy. All information is relevant and front-loaded. 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?

Covers all essential aspects for a simple delete tool: what, how (by id), where (scene), error handling, access restriction. No output schema needed; description is sufficient for an agent to invoke correctly.

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

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

Schema coverage is 100%, baseline 3. Description adds little beyond schema: drawingIds already mentions 'from list-drawings' and sceneIdentifier already says 'id or exact name'. The overall behavior note on missing ids is not parameter-specific, so minimal added value.

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

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

Clearly states the verb 'Delete', the resource 'Drawings', and the scope 'from a scene by id'. References list-drawings for ids. Distinguishes from sibling delete tools by explicit resource type and additional notes (missing ids non-fatal, GM-only).

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 context on when to use (for deleting drawings, ids from list-drawings) and behavior (missing ids reported, non-fatal) and access (GM-only). Lacks explicit when-not or alternatives, but context is clear enough for an agent to decide.

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 fully discloses behavior: irreversible deletion, default refusal for non-empty folders, and the option to delete contents. This covers safety and destructive nature comprehensively.

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?

Five sentences, each essential: action, restrictions, default behavior, optional override, param note. No redundancy. Front-loaded with critical warnings.

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

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

Despite no output schema, the description covers purpose, usage, parameters, and behavioral nuances completely. No gaps remain for a deletion tool of 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?

All three parameters have schema descriptions, and the tool description adds context: defaults to Actor folders, explains 'identifier' can be name or ID, and clarifies the avoidContents flag. The description matches the schema and adds value.

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

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

Clearly states 'Permanently delete a folder by exact name or ID', distinguishing from sibling tools like delete-actor or delete-item. The verb 'delete' and resource 'folder' are precise, and the scope 'GM-only, IRREVERSIBLE' adds specificity.

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

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

Provides clear when-to-use: GM-only, safe for cleaning empty folders, and when to pass deleteContents:true for forced deletion. Implies when not to use (when contents should be preserved). Could explicitly mention alternatives like moving items first, but the guidance is strong.

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

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

With no annotations provided, the description carries full burden. It discloses destructive nature ('permanently delete'), permission requirements ('GM-only'), and matching strictness ('STRICT resolution'). However, it does not mention error handling or side effects if identifiers are not found.

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

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

Three sentences, each purposeful. No redundancy. Front-loads action and resource, then adds constraints and alternatives.

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

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

Covers core action, input format, and when to use alternative. Missing explicit mention of return value or success/failure behavior, but for a deletion tool this is acceptable.

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 describes parameter generically; description adds crucial context: 'exact ids (preferred) or exact names', and reinforces strict matching. This goes beyond the schema's own parameter description.

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

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

The description clearly states the action ('permanently delete'), the resource ('world-level Item documents from Items sidebar'), and the method ('by exact id or exact name'). It distinguishes itself from the sibling tool 'remove-from-actor' by specifying 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?

Explicitly states 'GM-only' for permission context, specifies when not to use it (for embedded actor items, use 'remove-from-actor'), and emphasizes strict matching to avoid accidental deletion. Provides clear when-to-use and when-not-to-use guidance.

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

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

The description discloses destructive and irreversible operation ('permanently delete') and access restriction ('GM-only'), but with no annotations, it lacks details on effects (e.g., cascading deletes) or error handling. Adequate but not exhaustive.

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 fluff. Front-loaded with action and resource, followed by constraints. Every sentence adds value.

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

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

Given no output schema, the description does not mention return values (e.g., success/failure count). It covers the operation adequately but lacks completeness on expected output. With simple deletion and no annotations, a score of 3 reflects this gap.

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

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

Schema coverage is 100% with description of identifiers as exact ids or names. The description adds 'STRICT resolution' but does not provide additional meaning beyond schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool deletes JournalEntry documents by exact id or name, distinguishing it from create, update, list, and search siblings. The 'GM-only' and 'permanently' further specify scope and nature.

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 specifies when to use (exact identifiers) and constraints (no fuzzy matching, GM-only), but does not explicitly mention when not to use or compare with alternatives. However, sibling tools cover other operations, making the context clear.

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

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

Discloses that it deletes one page and leaves the rest intact, and that it is GM-only. Without annotations, this sufficiently describes behavior. Could mention permanence but it is implied.

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

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

Extremely concise: two sentences plus 'GM-only' tag. No redundant information, front-loaded with key action and 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?

Complete for a simple delete tool with clear schema and no output schema. Addresses what, how, and who.

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 describes both parameters with clear descriptions (pageId from list-journals, journalId as id or name). The description adds little beyond schema, but reinforces the source of pageId. Baseline 3 due to high schema coverage.

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

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

The description clearly states it deletes one page from a journal entry, specifying the use case of removing a stray/mistaken page. It distinguishes itself from sibling tools like delete-journal (deletes entire journal) and set-journal-page-visibility (hides page).

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

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

Explicitly states when to use this tool ('use to remove a stray/mistaken page instead of deleting and rebuilding the whole journal') and notes it is 'GM-only,' indicating the intended user.

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 discloses that missing ids are not fatal and that the tool is GM-only, but does not detail side effects, irreversibility, or cascading impacts on the scene.

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

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

Two sentences, no wasted words. Front-loads the core action and follows with important behavioral notes.

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 tool with two parameters and no output schema, the description covers the essential behavior, error handling, and access control. It is sufficiently complete for the tool's 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?

Schema coverage is 100%, so the schema already describes both parameters. The description adds minimal value by referencing 'list-lights' for id sourcing, but does not elaborate on format or constraints beyond the schema.

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

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

Description clearly states it deletes AmbientLights from a scene by id, specifying the resource and action. It differentiates from sibling delete tools by explicitly mentioning AmbientLights and scene context.

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

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

Provides useful guidance: missing ids are reported but not fatal, and only GMs can use it. Implicitly suggests using 'list-lights' to get ids. However, it lacks explicit when-not-to-use or alternative tools.

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

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

Without annotations, the disclosure of missing ids being non-fatal is valuable, but it omits details like whether deletion cascades, is reversible, or affects other data. 'GM-only' covers authorization, but more behavioral context would help.

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

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

Extremely concise with three sentences, each adding unique value. The action is front-loaded, and no redundant information is present.

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

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

For a simple delete tool, the description covers input, behavior on missing ids, and permission. It is slightly incomplete by not discussing idempotency or side effects on the scene, but this is forgivable given the tool's nature.

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

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

Schema covers both parameters with descriptions. The description adds contextual meaning by specifying that note ids come from 'create-scene-notes', which clarifies the expected format beyond the schema.

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

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

The description uses a specific verb 'Remove' and clearly identifies the resource as 'map-note pins' from a scene, distinguishing it from siblings that delete 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?

It states 'GM-only' for permission and notes that missing ids are not fatal, providing context for when to use. However, it lacks explicit guidance on when not to use or alternatives, though the sibling list implies this tool is for notes.

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

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

Describes permanent deletion, strict resolution, and GM-only requirement. Does not mention potential side effects like cascading deletes, but for a simple delete operation this is sufficient without annotations.

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

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

Two sentences, no wasted words, front-loaded with action and target. Every sentence adds value.

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

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

For a simple delete tool, the description covers what it does, how it identifies targets, and its constraints. No output schema needed; behavior is predictable.

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

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

Schema coverage is 100% with a clear description of the 'identifiers' parameter. The description adds the 'STRICT resolution' context, but the parameter is already well-documented in the schema. Meets baseline with minor added value.

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

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

The description clearly states the action (permanently delete), target (Playlist documents), and method (by exact id or exact name). It distinguishes itself from siblings like update-playlist and other delete tools for different document 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?

Explicitly states 'GM-only' for authorization and 'STRICT resolution — no fuzzy/substring matching' to clarify when not to use. Provides clear constraints for correct invocation.

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

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

Without annotations, the description carries the full burden. It discloses non-fatal missing id handling, orphan teleporter warnings, and GM-only restriction—valuable behavioral details beyond the basic delete 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 two sentences, each providing essential information: the core action in the first, edge cases and access restriction in the second. No redundant text, well-structured.

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

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

The description covers the main behavior and important edge cases (missing ids, orphan warnings) and access control. It does not mention return values, but for a deletion tool, the provided information is largely sufficient.

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

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

Schema coverage is 100% with clear descriptions for both parameters. The tool description adds minimal extra meaning beyond the schema, matching the baseline for high coverage.

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

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

The description clearly states the tool deletes one or more regions by id, specifying the action, target, and method. It distinguishes from sibling delete tools by targeting regions and adds unique details like reporting missing ids and orphan teleporter warnings.

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 deleting regions and indicates GM-only access, but it does not explicitly explain when to use this over alternatives like updating a region or when not to use it. No direct comparison to siblings 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 provided, but the description itself discloses permanent deletion, exact matching requirement, and GM-only restriction. This adequately informs the agent of behavioral traits 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?

Two concise sentences with no waste. The key information is front-loaded: action, target, method, constraints. 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 tool with one simple parameter and no output schema, the description covers all necessary context: what it does, how to specify documents, who can use it, and important caveats (permanent, strict matching). It is fully complete.

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

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

The input schema already describes the 'identifiers' parameter as 'Exact ids (preferred) or exact names'. The tool description reinforces 'STRICT resolution', but adds minimal new meaning. Baseline 3 due to 100% schema coverage.

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

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

The description clearly states the action (permanently delete), the target (RollTable documents), and the method (exact id or name). It also specifies strict resolution and GM-only access, distinguishing it from sibling tools like create-rolltable or update-rolltable.

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

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

The description provides clear guidance on when to use the tool (delete RollTables by exact id/name) and constraints (strict resolution, GM-only). It does not explicitly mention alternatives or when not to use, but the context is sufficient.

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, description fully discloses permanent deletion, GM-only requirement, and strict matching. No 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?

Two sentences, no fluff. Purpose, method, restrictions all covered 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 one-parameter deletion tool with no output schema, description covers all necessary aspects: action, identifiers, strictness, access.

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?

Parameter 'identifiers' is well-described in the schema. Description repeats but adds 'preferred' for ids. With 100% schema coverage, baseline is 3, no significant extra meaning.

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

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

Clearly states it deletes Scene documents by exact id or name, with strict resolution. Distinguishes from siblings like bulk-delete by specifying exact matching.

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?

States GM-only and strict resolution, implying use when exact identifiers are known. Does not explicitly mention alternatives but context is clear.

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

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

No annotations provided, so description carries full burden. It discloses that missing IDs are reported but never fatal, and that the tool is GM-only. It does not mention permanence or side effects, but for a delete tool this is adequate.

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, front-loaded with verb and resource. No unnecessary words; every phrase adds value.

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

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

For a simple delete tool with 2 parameters and no output schema, the description covers auth (GM-only) and error handling (missing IDs non-fatal). Could mention return value, but not critical.

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

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

Schema coverage is 100%, so baseline is 3. The description adds minimal value by referencing 'from list-sounds', which the schema parameters already include. No additional syntax or format details beyond schema.

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

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

The description clearly states the tool deletes one or more AmbientSounds by id, sourced from list-sounds, which distinguishes it from sibling tools like create-sounds, update-sounds, etc.

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 mentions GM-only, indicating restricted usage. It does not explicitly state when not to use or alternatives, but given it's a delete tool, the context is clear.

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

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

No annotations provided, but the description discloses that missing IDs are reported but not fatal, and that the tool is GM-only. It does not detail all side effects, but the destructive nature is clear.

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

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

The description is extremely concise—one sentence plus 'GM-only'—with no wasted words. It front-loads the action and key constraints.

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 action, input source, behavior on missing IDs, and authorization. Without an output schema, it would benefit from mentioning return behavior, but it is sufficient for the tool's simplicity.

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

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

Schema coverage is 100%, so the description adds minimal value beyond the schema. It references 'from list-tiles' for tileIds, but that is also in the schema description. 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 it deletes tiles from a scene by ID, specifies the source of IDs ('from list-tiles'), and explains behavior for missing IDs. It distinguishes the resource (tiles) from siblings like delete-drawings.

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 (when needing to delete tiles) and provides context via 'from list-tiles' and 'GM-only'. It lacks explicit when-not-to-use or alternatives, but the tool is straightforward.

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 fully discloses behavioral traits: it only affects the map instance (not actor), missing IDs are reported but never fatal, and it requires GM permissions. This is comprehensive and honest.

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 efficient sentences that front-load the core action and add necessary nuance (survival of actor, missing IDs, GM-only). Every sentence earns its place with no redundancy.

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

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

For a simple 2-param tool with full schema coverage and no output schema, the description covers key aspects. It could explicitly mention return behavior (e.g., list of missing IDs), but the note that missing IDs are reported implies this. Overall very solid.

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% (both parameters have descriptions). The description adds value by clarifying that tokenIds come from list-tokens and are 'placed tokens', and that the sceneIdentifier refers to a scene holding placeables. This enhances understanding beyond schema.

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

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

The description clearly states the tool removes placed tokens from a scene by token ID. It distinguishes from delete-actor by specifying that only the map instance is cleared while the sidebar actor survives. This is a specific verb-resource combination.

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

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

The description provides explicit guidance: use this tool to remove placed tokens without deleting the actor; use delete-actor for full removal. It also mentions prerequisites (token IDs from list-tokens), that missing IDs are safe (non-fatal), and that the tool is GM-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?

With no annotations, the description discloses key behaviors: GM-only authorization, non-fatal missing IDs, and the destructive nature (deleting walls). It could add details about irreversibility or response, but for a simple tool this is adequate.

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

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

The description is a single efficient sentence with three clear clauses covering purpose, example, error handling, and authorization. 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 2-parameter tool with no output schema, the description covers operation, error handling, and authorization. It lacks mention of prerequisites (scene/wall existence) or permanence, but the example and GM-only note provide reasonable 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 coverage is 100%, so the schema already describes both parameters. The description adds the example context but no new semantic details beyond reinforcing the IDs source and scene identifier purpose.

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

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

The description clearly states it deletes walls by ID from a scene, provides a concrete example ('open up a sealed passage'), and references the source tool ('list-walls'). This distinguishes it from other deletion tools among siblings.

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

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

It indicates when to use (delete walls), who can use it ('GM-only'), and error handling ('missing ids reported, never fatal'). Though it does not explicitly list alternatives, the context of 'by id from list-walls' implies a prerequisite, and the sibling list shows other delete tools.

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

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

No annotations are provided, so the description carries full burden. It mentions 'read-only' and downloads via WebDAV, which adds transparency. However, it does not disclose whether files are overwritten, error handling for missing files, or authentication 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 short and front-loaded with key information. The 'Plane B (file channel, read-only)' prefix is somewhat obscure but still concise. Every sentence serves a purpose.

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

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

For a simple download tool with two parameters and no output schema, the description provides adequate context: source, destination, and use case. Missing error handling or auth details, but acceptable for this complexity level.

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 that remotePath is relative to 'Data/ root', which clarifies the schema. No additional parameter semantics beyond what schema already provides.

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

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

The description clearly states the tool downloads a file from the Foundry Data/ root to a local path, specifying direction and resource. It distinguishes from upload, copy, delete, and list siblings by focusing on remote-to-local transfer for inspection or reprocessing.

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 hints at usage ('for grabbing an existing asset to inspect or re-process') but does not explicitly state when not to use it or compare to alternatives like copy-asset or asset-url. Guidance is implied but not explicit.

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

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

With no annotations, the description carries the full transparency burden. It discloses the safe read-only nature (no mention of deletion), overwrite refusal, remote password requirement, and formats. It could mention that it only exports the current chat log but the parameters allow filtering. Good overall transparency.

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

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

The description is concise—three sentences that front-load the main purpose and key behaviors. No unnecessary words or repetition. Every sentence adds information.

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

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

The description covers the tool's primary functions and constraints well. However, it does not specify the return value for local exports (only mentions public URL for WebDAV) and omits that parent directories are created for localPath (though schema mentions it). Given the complexity (6 params, no output schema), the description is nearly complete but has a minor gap in return value documentation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by summarizing the overall workflow (local and/or remote, overwrite policy, format kinds) and implying that at least one destination is needed (despite none being required in schema). This clarifies parameter relationships beyond the schema.

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

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

The description clearly states the tool exports a chat transcript to a local file and/or WebDAV path, specifying formats and overwrite behavior. It distinguishes itself from sibling tools like list-chat-messages or delete-chat-messages by focusing on export to persistent storage.

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 on when to use the tool (exporting chat logs), including prerequisites like MOLTEN_WEBDAV_PASSWORD for remote destinations and overwrite behavior. However, it does not explicitly compare to alternatives or state when NOT to use it (e.g., for simply reading messages instead).

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

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

No annotations are provided, so the description carries full burden. It states 'Read-only,' which is a clear safety signal. However, it does not elaborate on side effects, rate limits, or return format beyond the implicit finding of documents.

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

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

The description is extremely concise with three short sentences that front-load the purpose and usage. No unnecessary words, every sentence adds value.

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

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

For a simple one-parameter tool with no output schema, the description covers purpose, usage guidance, document types, and safety. It is adequately complete for an agent to understand and invoke the tool correctly.

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

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

Schema description coverage is 100%, with the parameter 'paths' fully described in the schema. The description does not add extra semantics beyond what is already in the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool finds references to an asset path across multiple document types, using a specific verb ('Find') and resource ('world documents'). It distinguishes itself from siblings like delete-asset or move-asset by specifying it should be used before destructive actions.

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

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

The description explicitly says 'Use this BEFORE deleting or moving a file to see what would break,' providing clear when-to-use guidance. It does not explicitly mention alternatives, but the context implies this tool is for pre-deletion/move checks.

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 the tool returns minimal metadata without descriptions and is optimized for token usage. It also notes that identifier can accept a token ID for live state. However, it does not explicitly state that the operation is read-only or safe, which would improve transparency.

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