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

The annotations already indicate readOnlyHint=false and openWorldHint=true, so the description doesn't need to reiterate side effects. It does add some context about generating scaffolds and loading modules, but it doesn't elaborate on state changes beyond what the annotations imply.

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

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

The description is two sentences with no redundant fluff. It efficiently conveys the core actions and usage constraints, making it easy to parse.

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

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

With six parameters and multiple action modes, the description provides a high-level overview but doesn't detail which parameters are required for each action or what the output format looks like (no output schema). It's adequate for basic guidance but leaves some ambiguity for complex use cases.

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

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

Schema coverage is 100%, so each parameter already has a description. The tool description adds no extra meaning to the parameters—it only hints at usage scenarios (e.g., 'single encounter' for generate_encounter) without elaborating on parameter interactions.

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

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

The description clearly states the tool's purpose with specific verbs ('generate, load, or list') and the resource ('adventure content'). It also explicitly distinguishes from the 'story' tool, helping the agent select the correct one.

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

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

The description provides explicit usage conditions ('Use when...') and counter-indications ('Do NOT use when...'), including a direct pointer to the alternative 'story' tool. This leaves no ambiguity about when to invoke this tool.

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

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

The description lists actions like 'remove' and 'roster_remove' which imply destructive changes, but it does not explicitly state that these actions are permanent or irreversible. Since readOnlyHint=false already signals mutability, the description adds some context but could be more explicit about side effects like deletion or state changes.

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

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

The description is a compact list of actions followed by clear use/when-not-to-use sections. It is not overly verbose, though it could be slightly more concise by grouping actions. The structure with 'Use when' and 'Do NOT use when' aids 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?

The description gives an overview of actions and the target audience (player characters), but lacks details on what each action actually does (e.g., what 'stage' means, what 'signal' sends). It does not mention prerequisites, error conditions, or expected outputs. Given the tool's complexity (25 parameters, many actions), this is a moderate gap.

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

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

Schema description coverage is 100%, so the baseline is 3. However, many descriptions are terse (e.g., 'details: Grouped mechanical details (create)', 'value: Feedback text (signal)') and only restate parameter names plus the action they relate to. They do not explain formats, allowed values, or relationships, though they do provide some minimal context like which action uses each parameter.

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

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

The description clearly states the tool's purpose as managing player characters, enumerating specific actions like create, stage, import, sheet, set_active, personality, voice, signal, remove, and roster_list. It also provides explicit use-case guidance ('Use when: working with player characters'), making it immediately clear what the tool is for.

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

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

The description provides explicit usage boundaries with 'Use when: working with player characters' and 'Do NOT use when: managing NPCs — use npc,' which directly points to an alternative tool. This gives clear guidance on when to select this tool over others.

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 enumerates the action variants (set, list, get, capture, import, delete) and the openWorldHint aligns with cross-Novel reuse. It does not detail side effects or destructive implications of delete, but the annotations already indicate mutability.

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 tight sentences pack the resource, operations, scoping, and disambiguation without fluff. Information is front-loaded and easy to scan.

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

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

The description is sufficient for correct tool selection and covers the cross-Novel library concept, actions, and the key boundary with lore/note. No output schema is declared, so return-value documentation is not required here.

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

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

All 10 parameters including the action enum are described with inline usage hints. The description adds a little context but mostly relies on the schema, which is fully covered, so a baseline score 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?

States a specific resource (cross-Novels codex library of reusable content) and a clear set of management operations. Explicitly distinguishes it from Novel-scoped lore/note tools, leaving no ambiguity about 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?

Provides explicit 'Use when' and 'Do NOT use when' guidance with named alternatives (lore/note), making it easy for an agent to decide when to invoke this tool versus siblings.

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

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

The description implies state changes (manage, start, advance, end) and matches the readOnlyHint=false annotation. However, it does not detail exactly what happens with each action (e.g., what 'advance' does to the combat state), leaving some behavioral details implicit.

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

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

The description is compact and to the point, using a single sentence plus explicit use-case guidance. It avoids redundancy and focuses on the essential information an agent needs.

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 provides enough context for the tool's role and action types, but it does not mention return values or output format, which could be useful for an agent to fully understand the tool's behavior. However, given the action-oriented nature, the missing output info is a minor 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?

All parameters are covered by schema descriptions that clearly explain their purpose and which action they apply to (e.g., participants for init, outcome for end, participant_id for add/remove). The descriptions add value beyond the raw schema by tying each parameter to its action 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 the tool manages combat encounters in the active Novel, with explicit use cases (starting, advancing, ending, changing participants) and a clear distinction from the sibling 'condition' tool for status effects.

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 specifies when to use (starting, advancing, ending, changing participants) and when not to (status effects, with a pointer to the condition tool), leaving no ambiguity about its scope.

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 that resolve does not mutate state, but it does not clearly disclose whether execute mutates state, persists changes, or has side effects. The readOnlyHint annotation is false, which implies potential mutation, yet the description leaves the exact behavioral impact vague. No error, permission, or rollback behavior is mentioned.

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

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

The description is compact and structured into use/no-use sections without excessive verbosity. The action-mode list is dense but not redundant. It could be slightly clearer by separating each mode into its own sentence, but the current format 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?

The description provides core usage rules but omits examples, expected output format, and specifics about how suggest maps intents to tool calls. It also does not mention which sibling tools are candidates for suggestion or how resolve returns non-mutating results. Given the tool's central role and lack of an output schema, this gap leaves some operational ambiguity.

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

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

The schema provides a description for every parameter, including the action enum values, and the description adds a useful default for action ('Defaults to execute'). The relationship between action and the other parameters (intent, command, entity_id) is reasonably clear from the schema. With 100% schema coverage, the incremental description value is modest but still helpful.

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

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

The description clearly names the tool's core purpose—executing parser commands, resolving spatial intents without mutation, and suggesting actions from intent. The three action modes are stated directly, and the 'Do NOT use' clause distinguishes it from world/lore inspection. Minor ambiguity remains around what 'parser command' and 'spatial intent' concretely involve, but the overall purpose is identifiable.

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 'Use when' section maps each action enum value to a concrete scenario, giving an agent clear selection criteria. The 'Do NOT use' clause explicitly routes GM model inspection to world/lore tools. It does not enumerate all sibling-tool alternatives, but the provided guidance covers the main decision points.

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

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

Annotations already declare readOnlyHint=false, so mutation is implied. The description adds the context of 'mechanical or narrative conditions' but does not specify side effects (e.g., whether removal clears all instances or just one). Still, it sufficiently conveys the tool's mutating nature without contradiction.

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

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

Two sentences efficiently convey purpose and usage boundaries. The structure is clear and front-loaded with the core action. Slight redundancy in the 'Use when' list could be trimmed, but overall it is concise and scannable.

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 simplicity of the tool (no output schema, flat parameters), the description covers the essential context: what it does and when to use it. It lacks only a mention of return values or error handling, but these are not critical for such a straightforward 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 covers 100% of parameters with brief descriptions. The tool description does not add extra meaning beyond these, so it meets the baseline but provides no additional semantic depth (e.g., what 'rounds' means in context or how 'entity_id' references entities).

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 tool manages conditions, lists specific actions (apply, remove, list), and distinguishes from the combat tool. The verb 'manage' is specific to this resource, and the contrast with combat prevents confusion.

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 provides both positive usage ('when applying, removing, or listing conditions') and negative usage ('Do NOT use when recording damage or combat state'), naming the alternative tool (combat). No ambiguity about when to invoke this tool.

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

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

The description does not mention any side effects, state changes, or world modifications. While the annotations (readOnlyHint: false) indicate that the tool mutates state, the description itself adds no behavioral context beyond the generic verb 'manage'.

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, using two clear sentences with direct guidance. The 'Use when' and 'Do NOT use when' structure makes it easy to scan and apply, with 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 the simple nature of the tool and the complete schema coverage, the description provides sufficient context for correct usage. It covers the primary action list, the exclusion case, and a pointer to the sibling tool, making it self-contained.

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

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

The schema provides descriptions for all parameters (100% coverage), so the baseline is met. The tool description does not add extra meaning to the parameters; it only lists actions that map to the enum values. No further clarification is needed 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 manages countdown timers and lists the specific actions: starting, advancing, removing, or listing clocks. It also distinguishes from vow tracking by pointing to the vow tool, 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?

Explicit usage guidance is provided: 'Use when: starting, advancing, removing, or listing clocks' and 'Do NOT use when: tracking a vow's progress — use vow (action: milestone)'. This gives clear direction and a named alternative.

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

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

Annotations already indicate readOnlyHint=false, so modification is expected. The description adds context about managing factions and progress clocks but does not detail side effects like deletion or state changes beyond that. It does not contradict annotations.

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

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

Concise and well-structured, using 'Use when' and 'Do NOT use when' for clarity. No unnecessary words or redundant information.

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

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

No output schema so return values are not needed. The description covers core actions and exclusions. Slight ambiguity remains about 'progress clocks' not being in the schema, but overall it is sufficient for an agent to decide when and how to use 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 descriptions cover all parameters with high coverage (100%), so the tool description adds no additional parameter semantics. 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?

Clearly states the tool manages factions (create, update, remove, list) and explicitly distinguishes it from the world tool for territory rooms. Specific verbs and scope leave no ambiguity.

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 'Use when' and 'Do NOT use when' conditions, referencing a sibling tool (world) and giving clear guidance on when to choose this tool.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, indicating mutating side effects. The description adds context by listing state-changing operations (spending/refreshing points, marking stress), which aligns with annotations. However, it doesn't disclose reversibility, permission requirements, or potential side effects on entities, so it adds moderate value beyond annotations.

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

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

The description is two sentences, front-loaded with the core purpose and usage conditions. It avoids filler and directly states exclusions and alternatives. Every sentence earns its place.

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

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

Given the tool's complexity (14 params, 4 action types), the description covers the main operations and usage boundaries. It doesn't explain return formats, but no output schema exists; however, the description is clear enough for an agent to invoke the correct action. Minor gaps like how invokes resolve or what the roll result looks like are 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 description coverage is 100%, so all 14 parameters are documented in the schema. The description does not add any parameter-specific meaning beyond the schema, only domain context (e.g., 'Fudge dice'). Since coverage is high, the baseline of 3 is appropriate; no compensation 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 a specific verb and resource: 'Resolve Fate-style actions with Fudge dice, aspects, Fate points, and stress.' It distinguishes itself from siblings by explicitly naming an alternative ('the bound ruleset's roll tools or command (action: resolve)') for d20 checks, so an agent can tell it apart without inspecting other schemas.

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

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

Provides explicit when-to-use conditions ('rolling 4dF against a difficulty, invoking or compelling aspects, spending or refreshing Fate points, or marking stress and consequences') and when-not-to-use with a concrete alternative. This leaves no ambiguity about selection criteria.

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

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

The description discloses the mutating sub-operations (mark/clear/resist stress, recover/indulge vice) and the random/deterministic nature of action rolls via dice and seed, which goes beyond the minimal readOnlyHint/openWorldHint annotations. It does not contradict the annotations, though it could state persistence or side effects 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?

The description is short and front-loaded: a one-sentence purpose, followed by crisp use/no-use guidance. Every sentence adds information, and the formatting makes the selection criteria easy to scan.

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

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

For a tool with no output schema, the description provides enough operational context to choose and invoke the correct sub-operation, including defaults and exclusions. It does not describe output shapes, but that is less critical given the explicit schema and the simple sub-operation model.

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 descriptions already cover all 10 parameters with defaults and enums, so the description adds little beyond grouping them into sub-operations. It reinforces the role of cost, dice, position, and effect, but does not substantially extend the schema's meaning.

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

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

The description opens with a specific verb ('Resolve') and names the exact domain (Blades in the Dark-style actions), then enumerates the three supported areas: action rolls, stress/resistance, and downtime recovery. It also distinguishes itself from countdown tracking, leaving no ambiguity about what the tool does.

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

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

It provides explicit 'Use when' conditions for each supported kind of roll and a 'Do NOT use when' rule that routes progress-clock tracking to the countdown tool. This gives an agent clear selection criteria and an explicit alternative.

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

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

The annotations declare readOnlyHint: true, but the description includes 'reassign a tool's category', which implies a state-changing mutation. This directly contradicts the read-only annotation and could mislead an agent about side effects. The contradiction is serious enough to warrant the lowest score.

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

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

The description is compact and front-loaded, stating the core action first before adding usage guidance. Every sentence serves a purpose, and there is no redundant or filler content.

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

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

The description covers the main behavior and usage boundaries, but it does not describe the output format or the result of a category reassignment. Since there is no output schema, some return-structure details would help complete the picture, though the core invocation context is present.

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

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

All four parameters are described in the schema with 100% coverage, including the enum constraint on action. The description adds practical context such as null/empty restoring the default category. No parameter meaning is left unclear.

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 shows available tools grouped by category or reassigns a tool's category. It also specifies when to use and when not to use it, distinguishing it from badge_briefing. This gives an agent a precise sense of 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?

Explicit use cases are provided: discovering tools, finding by keyword, or overriding a category for a session. The description also gives a clear negative case with a pointer to the alternative prompt, leaving no ambiguity about when to invoke this tool.

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

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

The description uses verbs like 'setting', 'burning', 'rolling', 'marking', and 'testing' which imply state changes, but it does not explicitly describe side effects, output formats, or failure modes. Since readOnlyHint is false, the agent might expect modifications, but the description misses the opportunity to clarify what the tool returns or how it affects game state. It is adequate but not detailed beyond the annotations.

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

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

The description is compact and well-structured: one core statement, a 'Use when' list, and a clear negative condition. Every sentence serves a purpose, and it avoids fluff or repetition. It is highly efficient for an agent to parse.

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

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

Given the tool's complexity (10 parameters, no output schema), the description covers the main scenarios but leaves out details like how challenge dice interact with parameters, what the expected outcomes are, or how progress tracks behave. However, the schema's parameter descriptions and the explicit use-case list provide enough context for basic usage. It is sufficient but not exhaustive.

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

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

The schema fully describes each parameter with individual descriptions, so the baseline is 3. The tool description only echoes the schema mentions (setting momentum, move rolls, progress tracks) without adding deeper meanings, relationships between parameters, or examples. It does not improve on the schema's already-present semantic 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's purpose: resolving Ironsworn-style actions including momentum, move rolls, and progress tracks. It distinguishes itself from the sibling 'vow' tool by explicitly saying not to use it for managing vows, which makes its scope 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 provides explicit 'Use when' conditions for setting/burning momentum, rolling moves, and marking/testing progress, and a 'Do NOT use when' condition with a direct pointer to the 'vow' tool. This gives the agent clear actionable guidance on when to select this tool 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?

The descriptions do not contradict the annotations (readOnlyHint: false implies write operations, which align with creating/revising/removing). However, the description does not add extra context beyond what the annotations already convey, such as side effects or permission requirements. The presence of secret-related actions (set_secret, reveal, secret_list) is not explicitly explained, but the core write behavior is transparent.

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

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

The description is concise, consisting of two sentences. It efficiently states the purpose and usage boundaries without unnecessary elaboration, making it easy for an agent to parse and act on.

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 provides enough context for the tool's core function and when to use it. Given the tool supports multiple actions (set, update, remove, etc.), the description captures the overall scope but doesn't enumerate every action. This is sufficient for a high-level tool definition, especially with a comprehensive 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?

The schema already provides descriptions for all parameters (100% coverage), so the description does not need to add parameter semantics. It does not go beyond the schema, which is acceptable given the high coverage. The baseline score of 3 is appropriate.

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

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

The description clearly states the purpose: 'Manage the active Novel's lore entries (world facts the narrator recalls).' It uses a specific verb ('Manage') and resource ('lore entries'), and explicitly differentiates from the sibling tool 'story' by saying 'Do NOT use when: recording a story beat — use story (action: record).'

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

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

The description provides explicit usage criteria: 'Use when: creating, revising, removing, toggling, grouping, suggesting, listing, exporting, or importing lore.' It also gives a clear exclusion: 'Do NOT use when: recording a story beat — use story (action: record).' This leaves no ambiguity about when to invoke this tool.

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

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

The description indicates notes are managed and scoped, and the readOnlyHint is already false, so there is no contradiction. However, it does not disclose whether actions permanently delete or only update notes, and no output behavior is mentioned, leaving some behavioral details implicit.

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 brief, front-loaded with the core purpose, and uses a clear 'Use when' / 'Do NOT use when' structure. Every sentence contributes directly to orienting the agent.

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

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

The description places notes in the broader context of scratch state versus durable lore, which is important given sibling lore and world tools. It does not explicitly explain required parameters for actions like set or the return format, but the schema and enums fill most 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?

The schema covers all parameters with descriptions and enums, so the description adds little beyond that. The parameter descriptions are mostly tautological, and the tool description does not clarify parameter relationships (e.g., which parameters apply to which actions), but schema coverage is complete.

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 resource as Novel-scoped notes and distinguishes its purpose from lore by framing it as scratch state. The verb 'Manage' is somewhat generic, but the explicit 'Use when' / 'Do NOT use when' contrast with lore makes the intended purpose clear.

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

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

The description provides explicit guidance on when to use the tool ('storing scratch state the caller will reuse') and when not to use it, directing to lore instead. This makes the tool's appropriate usage unambiguous relative to sibling tools.

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

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

The action list implies effects such as create, end, archive, and checkpoint_remove, and the annotations indicate read-write open-world behavior. However, the description does not elaborate on side effects, persistence, or how open-world changes propagate beyond the save file.

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

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

The description is compact and front-loaded with the action list, followed by clear use and non-use guidance. There is no redundant prose or unnecessary detail.

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

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

For a tool with many actions and parameters, the description gives a useful high-level frame but leaves operational details—such as action-specific behaviors, return data, and how context saving/checkpointing works—to be inferred from the schema or elsewhere.

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 each parameter description includes the action(s) it applies to. However, most descriptions are terse labels (e.g., 'Genre tag (create/genre)') and enum values are repeated from the schema without deeper explanation, so semantic depth is limited.

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 managing Novel save files for campaign lifecycle, interchange, and return points, and explicitly contrasts it with entity-content tools. It lists the main action categories, though a few subactions like checkpoint_set are only implied by the umbrella term 'checkpoint'.

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?

Explicit 'Use when' and 'Do NOT use when' guidance is provided, with a clear pointer to entity tools for content management. This makes it easy for an agent to decide when to invoke this tool versus its siblings.

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

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

Annotations indicate readOnlyHint=false and openWorldHint=true, but the description does not add further behavioral details such as side effects of destructive actions (e.g., remove) or any preconditions. The schema's action enum partially covers this, but the description itself offers no extra behavioral context.

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

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

The description is concise (two sentences) and front-loads the primary purpose, followed by usage guidance. It avoids unnecessary detail while covering the essential information, making it easy to parse quickly.

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 (9 parameters, nested 'mind' object, no output schema), the description provides sufficient context for when and how to use it. It does not describe return values or detailed behavior per action, but the action enum and parameter descriptions fill most gaps. A short example or note on output could improve completeness, but it is not critically missing.

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

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

The parameter descriptions in the schema already provide context (e.g., 'NPC name (create)', 'Optional GM-only NPC mind (create/update)'), and the tool description reinforces the action scope. While the tool description does not elaborate on each parameter individually, the schema coverage is high and the existing descriptions are meaningful, adding value beyond bare names.

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

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

The description clearly states the tool manages non-player characters in the active Novel and lists specific actions (introducing, revising, removing, listing, reading). It explicitly distinguishes from the sibling 'character' tool for player characters, making the purpose unambiguous and well-differentiated.

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 'Use when' and 'Do NOT use when' instructions, directing agents to the 'character' tool for player characters. This gives clear guidance on when to select this tool 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?

Describes the mutating effect of restoring a removed snapshot, going beyond the readOnlyHint:false annotation. Does not mention failure cases or lack of undo history, but core behavior 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?

Two compact sentences deliver purpose, scope, and usage boundaries without redundant wording.

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

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

Fully sufficient for a zero-parameter mutation tool: it explains what it does, when to use it, and when not to use it, with no output schema requiring further detail.

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

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

No parameters exist, so there is nothing extra to document. Baseline for zero-parameter tools is appropriately strong.

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 action (re-apply), the target (most recently undone mutation/per-badge snapshot), and distinguishes it from undo by explicitly naming the counterpart.

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 use-when and do-not-use-when guidance, making the appropriate calling context unambiguous.

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

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

The description explicitly mentions both 'setting' and 'reading', which aligns with the readOnlyHint=false annotation and makes the read/write nature transparent. It does not detail side effects like persistence or mutation semantics, but that is not required given the annotation already covers the read-only aspect.

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

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

The description is extremely concise at two sentences, with a clear structure: a general statement of purpose, followed by explicit use-case and non-use-case guidance. Every sentence adds value, and there is no redundant or extraneous information.

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

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

Given the tool's moderate complexity (7 parameters, 1 required, no output schema), the description provides sufficient context for an agent to decide when to invoke it and how to differentiate it from the faction tool. It covers selection and usage without needing to explain return values 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?

The schema provides 100% description coverage for all 7 parameters, each with a clear description. However, the tool description itself adds no additional parameter-level semantics beyond what the schema already states. Per the baseline rule for high schema coverage, this is adequate but not enhanced.

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 tool's purpose: managing directed relationships between entities, NPCs, or factions. The phrase 'setting or reading how two parties relate' further clarifies the core functionality, and the explicit contrast with the faction tool removes ambiguity about 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?

Provides explicit when-to-use and when-not-to-use guidance. 'Use when: setting or reading how two parties relate' tells the agent exactly the scenarios, and 'Do NOT use when: tracking faction progress — use faction (action: update)' directs to the appropriate sibling tool, leaving no guesswork.

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 key behaviors: atomically draining the decision, persisting the outcome, and supporting 'cancel' to abort and restore a snapshot. Does not describe every possible side effect, but the essential behavioral contract 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 compact and well-structured, with usage conditions clearly separated. Every sentence adds useful 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?

Provides enough context for an agent to know when to invoke the tool and what the option parameter means. Since no output schema is present, some return behavior is unspecified, but the core usage is 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?

Both parameters have meaningful descriptions that go beyond their names. 'decision' defines what text is expected, and 'option' explains the chosen value plus the special 'cancel' behavior.

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

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

Clearly states the tool answers a pending workflow decision and explicitly scopes it to the server's [NEED_INPUT] prompt. It distinguishes itself from set_badge and state tools with explicit do-not-use guidance.

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 when-to-use and when-not-to-use instructions, including the condition of a pending [NEED_INPUT] prompt and the alternative of using set_badge or a state tool.

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

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

The description discloses side effects and read-only behavior: 'install/remove mutate installed-package state and are audited; search and roll are read-only.' This goes beyond the annotations (readOnlyHint: false) by specifying which actions are mutating and which are not.

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

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

The description is concise and well-structured: a single introductory sentence listing actions, followed by usage guidance and a side-effect note. It is front-loaded with the most important information and contains no 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?

The description covers the range of actions, usage conditions, and side effects, making it contextually complete for selecting and invoking the tool. However, it does not describe the return values or output format, which would be useful since there is no 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?

The schema already covers all parameters with descriptions indicating the applicable action (e.g., 'Deterministic seed (roll).'). The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Manage ruleset packages' and enumerates the specific actions (search, install, remove, list, bind, roll). It is specific and differentiates from alternatives by explicitly naming when to use command and session tools instead.

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 'Use when' and 'Do NOT use when' sections, including alternatives (command with action: suggest, session with action: health). This gives clear guidance on when to select this tool over others.

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

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

The description only says 'manage' without specifying side effects, such as overwriting existing scene state or interacting with other systems. The annotations (readOnlyHint=false, openWorldHint=true) imply mutation, but the description adds no concrete behavioral details beyond that, leaving the actual state-changing effects vague.

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, using a single sentence plus a compact list of use cases and a negative directive. It avoids redundancy and is well-structured for quick parsing.

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 with 23 parameters, nested objects (e.g., fast_forward, choices), and multiple actions, the description is far too brief. It does not explain the semantics of the many actions (e.g., what 'autonomy' or 'oracle' entails) nor how to properly construct nested objects, leaving the agent without enough context to use the tool effectively in all cases.

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

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

Although the schema covers 100% of parameters, most descriptions merely repeat the parameter name or enum list (e.g., 'Safety tier (autonomy)' or 'set, directive, presence, autonomy, choices, or oracle.'). They add little semantic value beyond the schema's type and enum definitions, failing to explain what each parameter actually means or how it influences tool behavior.

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

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

The description clearly states it manages the active scene and its narrative framing, enumerating specific use cases like setting scene state, directives, presence, autonomy, choices, and oracle rolls. It explicitly distinguishes from the story tool (recording beats), 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 provides explicit 'Use when' and 'Do NOT use when' guidance, directing users to the story tool for recording beats. This clearly delineates when to select this tool over its primary sibling, satisfying the usage guideline requirement.

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

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

The annotations indicate readOnlyHint: false, so the tool may modify state. The description mentions actions like 'compress' and 'reorder', implying state changes, but does not detail side effects or irreversibility. It adds some behavioral context beyond the annotation but lacks full transparency.

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

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

The description is a single, focused paragraph with a clear structure: a summary, a list of use cases, and a negative instruction. It is concise and free of 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?

The description covers most actions but omits the 'subscribe' action present in the schema. It also does not explain the exact output or consequences of each action, leaving some gaps for a tool with multiple behaviors.

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

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

The schema provides complete descriptions for all six parameters, and the tool description does not add significant clarification. Since schema coverage is 100%, the description's contribution is minimal, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool manages session-level surfaces and diagnostics, and enumerates specific actions (recap, verbosity, briefing_order, compress, health), plus a negative use case. This leaves no ambiguity about the tool's 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?

The description explicitly provides 'Use when:' and 'Do NOT use when:' conditions, giving the agent direct guidance on when to invoke this tool versus alternatives, such as the story tool.

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

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

The description explains that the tool changes the active badge and affects tool access server-side for the session, which goes beyond the minimal annotations. It does not detail all side effects, but the main behavioral impact 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 compact and front-loaded, covering purpose, usage, and exclusions in two sentences without unnecessary detail.

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

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

For a simple single-parameter tool, the description supplies enough context for correct invocation, including when to use it and when to choose a different tool. No output schema exists, so no return-value documentation is expected.

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

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

The sole parameter 'badge' is fully documented by the schema with an enum and description. The tool description adds no extra semantic information beyond what the schema already provides, so the baseline score applies.

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

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

States a specific verb ('switch'), the resource (active badge), the valid values, and the purpose (gating tool access). It also distinguishes itself from the sibling tool 'respond' by explicitly saying when not to use 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?

Provides explicit 'Use when' and 'Do NOT use when' guidance, naming the alternative tool and the condition that selects it. Nothing is left to inference.

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

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

The description names mutating actions like remove and update, which aligns with the readOnlyHint=false annotation and does not contradict it. However, it does not elaborate on side effects, persistence, or whether operations are reversible, leaving some behavioral ambiguity.

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

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

The description is compact and front-loaded, with a single clear purpose sentence followed by usage direction. It avoids unnecessary detail while still covering the essential scope.

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

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

The description gives a high-level overview but does not specify which parameters are required for each action (e.g., record needs type and entry; promote needs index and key). An agent might struggle to construct a valid call for a particular action without additional inference.

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 eight parameters have descriptions, but several are terse or ambiguous (e.g., 'key' is described as 'Optional lore key (promote)' without explaining its exact role). The enum values for action, type, and filter are listed but not deeply contextualized for each operation.

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

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

The description clearly states the tool manages a story journal with typed narrative memories and enumerates the supported actions (record, update, remove, list, promote). It also explicitly contrasts with the lore tool for durable world facts, making its scope unambiguous.

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

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

It explicitly lists when to use the tool (recording, editing, removing, listing, or promoting story beats) and provides a direct 'Do NOT use' condition directing durable world facts to lore. This gives clear guidance for tool selection.

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

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

The description implies write/mutating behavior through 'Manage' and actions like revert/activate/deactivate, but it does not disclose side effects, persistence, or destructive consequences. Since readOnlyHint is false, this is not contradictory, but agent expectations about state changes are left unstated.

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

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

The description is compact and front-loads the resource and action list with no unnecessary prose. The 'Use when' sentence is somewhat redundant with the enum values, but it still serves as clear usage guidance.

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

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

Covers resource, action scope, when to avoid, and the sibling alternative. It does not describe output/return shape or define terms like 'synthesis items' in depth, but with schema descriptions and sibling context it is reasonably complete.

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

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

All 9 parameters are covered by short descriptions, and several include parenthetical action mappings such as 'Item key (activate: number; player_add/player_remove: string)' and 'Return full entries (list)'. Descriptions are terse but functional.

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?

Identifies the resource as synthesis content and lists examples like voice examples, lore templates, action patterns, and other Ruleset Wisdom. It enumerates the supported actions, but the core verb 'Manage' is broad and relies on the action list to make the purpose concrete.

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 an explicit 'Use when' list covering the action categories and a 'Do NOT use when' clause directing codex browsing to the sibling codex tool. This gives an agent clear positive and negative selection guidance.

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

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

Annotations already indicate mutation (readOnlyHint false). The description adds the mechanism ('restoring the prior per-badge snapshot'), giving concrete insight into the side effects without contradicting the annotations.

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

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

Two concise sentences deliver the action, scope, and usage guidance without fluff. The key verb and object lead immediately, and the anti-guidance is tightly integrated.

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

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

With no parameters or output schema, the description fully covers what an agent needs: what it does, when to invoke it, and when to prefer an alternative. No gaps remain.

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

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

The tool has zero parameters, so the schema is trivially fully covered. Per the rubric, 0 parameters warrants a baseline of 4; the description adds no param info because none is 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's verb ('Undo') and target ('state mutation', 'per-badge snapshot'), making it distinct from siblings like 'redo' and 'set_badge' without needing to inspect schemas.

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

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

Explicitly provides when to use ('reverting a mistaken or unwanted change') and when not to use ('re-applying an undone change — use redo'), leaving no ambiguity for an agent.

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 names each action and its effect (e.g., resolving requires an outcome, forsaking requires a reason). Annotations indicate readOnlyHint is false, so the mutating nature is consistent. No contradictions or hidden side effects.

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

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

The description is just two sentences, yet conveys purpose, use cases, and a critical exclusion. It is well-structured and free of unnecessary detail.

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

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

Given the schema covers all parameters and the description explains the actions and their parameters, the tool is fully specified for an agent. No output schema is needed for a mutation tool, and the openWorldHint annotation aligns with the narrative 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?

All 10 parameters have descriptions, and the schema description coverage is 100%. Each parameter's description includes the action it applies to (e.g., 'Vow name (milestone/resolve/forsake)'), which clarifies conditional usage.

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

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

The description clearly states the tool tracks narrative vows with milestones and lists the five actions (set, milestone, resolve, forsake, list). It also distinguishes itself from the countdown tool, making its purpose unambiguous.

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

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

Explicitly states when to use (setting, advancing, resolving, forsaking, listing vows) and provides a negative instruction ('Do NOT use when: starting a clock timer — use countdown'), which is excellent guidance for an agent.

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

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

Annotations only mark readOnlyHint false; the description adds that operations include destructive changes like 'removing' and conversions, making mutating behavior explicit. No contradiction with the annotation.

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

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

The description is one short sentence plus two use-condition clauses, front-loading the action and alternatives. It avoids listing parameters, which are handled by the schema.

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

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

The description plus fully annotated schema gives enough context to select and invoke actions correctly. It omits return-value details, but the operations are straightforward mutations; still, without an output schema, a brief note on result would improve completeness.

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

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

All 27 parameters have schema descriptions, and most parenthetical notes indicate which action consumes them (e.g., 'create_exit/remove_exit'). Some terms such as 'hybrid world-model source text' and allowed directions are still vague, so it does not reach 5.

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

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

The description names specific actions ('creating, updating, removing, or bulk-converting') and the managed resource ('world model — rooms, things, and exits'), making its purpose unmistakable. It also distinguishes it from 'command (action: execute/resolve)' for navigation, so an agent can pick it 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 explicitly states 'Use when' for CRUD/convert operations and 'Do NOT use when' for navigation, pointing to command action execute/resolve. This gives clear selection criteria.

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