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

No annotations are provided, so the description carries full behavioral burden. It discloses atomicity ('atomically') and durability ('durable entities'), which are critical operational traits. It also explains local refs and forward references, clarifying how changes can reference each other. Missing details like failure modes or rollback behavior are partially covered by atomicity, but not fully elaborated. Overall, it provides enough behavioral context for safe invocation.

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, both dense with information. Key operational details (atomicity, refs) are front-loaded, followed by usage guidance. No wasted words; every clause earns its place. Ideal conciseness.

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

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

For a complex batch tool with three action types and nested object schemas, the description covers the essential operating contract: atomicity, refs, and appropriate usage. It does not mention the 100-item limit or the eventSecret secret-entity rule, but those are schema-encoded. Given the schema's richness and the description's focus on behavior, it is sufficiently complete for an agent to understand the tool's purpose and constraints, though a note on error handling would elevate it.

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

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

Schema covers 75% of parameters (summary, worldId, eventSecret have descriptions; changes does not). The description adds a nuance about local refs and forward references beyond the schema's generic ref mentions. However, it does not specify how 'changes' should be structured overall, and the schema already documents most parameter semantics. The added value is marginal but non-zero.

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

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

The description clearly states the action (create, update, delete) and resource (durable entities) performed atomically in one call. It distinguishes itself from sibling tools like update_world or create_checkpoint by emphasizing batch atomicity and multi-entity support. The verb-resource pair is specific and unambiguous.

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

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

The description provides guidance on when to use the tool: 'Store only lasting or story-relevant changes, preferably together at natural story boundaries.' This implies batching at narrative milestones and filtering for durable changes. However, it does not explicitly name alternative tools or state when NOT to use it (e.g., for single-entity updates), leaving some inference to the 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?

With no annotations, the description carries the full behavioral burden. It goes beyond the schema by stating that the server does not classify or rewrite content, making it clear that the tool stores what it is given. The 'strictly separated' and GM-only phrasing also signals access semantics and data-handling 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?

Two sentences deliver the core behavior, content separation, and the server's non-rewriting guarantee with no wasted wording. The sentence is front-loaded and free of tautology.

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 simple flat parameter set, no output schema, and no enums or nested structures, the description plus schema supplies what a caller needs for a correct create operation. A missing explicit usage boundary and a description of the returned checkpoint identifier 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?

The input schema already provides detailed guidance for worldId, gmNotes, and playerRecap, covering 75% of parameters; title is self-explanatory. The description adds orientation about recap and GM-note separation but does not introduce new parameter-level semantics.

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 explicitly states it "Create[s] a checkpoint" and characterizes its two core content types: player-safe recap and GM-only notes. This is a clear verb+resource statement and it is naturally distinguished from siblings like list_checkpoints or update_world.

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

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

No guidance is provided on when to create a checkpoint versus setting current scene, listing checkpoints, or applying world changes. The intended usage must be inferred entirely from the tool name and the word 'checkpoint.'

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 present, so the description carries full burden. It reveals that the 'description' parameter holds tone/settings, but doesn't disclose persistence, side effects, authorization, or what 'isolated' means operationally. For a create/mutation tool this is under-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?

Two short sentences, efficient and front-loaded, but at the expense of needed context.

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?

A create tool with no annotations and no output schema needs to explain return value or side effects. None provided. Sibling context (update_world, set_current_scene) raises questions about whether creation also activates the world, which isn't addressed.

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

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

With only 33% schema coverage, the description should compensate. It only clarifies the 'description' parameter ('holds its durable tone...'). No help for 'name' (required) or 'summary' 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?

Clearly states the verb 'Create' and resource 'RPG world/campaign'. Calls it 'isolated' adding scope. Distinguishes from sibling 'create_checkpoint' and update/delete 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?

Implies usage for creating a new world but provides no explicit when-to-use or alternatives. The word 'isolated' hints at separation but no routing guidance.

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

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

Beyond the destructiveHint annotation, the description reveals that deletion cascades to all related entities, scenes, checkpoints and events, and requires an exact confirmation string. This is valuable behavioral context that prevents accidental destructive calls and explains the guardrail.

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 key behavior, scope, and confirmation requirement without redundancy. The destructive nature is front-loaded, making it immediately visible to an agent.

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

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

Given the destructiveHint annotation, two simple parameters, and no output schema, the description is sufficiently complete. It explains what gets deleted, the confirmation safeguard, and how to identify the world, leaving no critical gap for correct invocation.

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

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

Schema coverage is only 50% because the confirmation parameter lacks a description. The description compensates by specifying the exact required format: 'DELETE: <world name>'. It also references list_worlds and create_world indirectly through the schema description for worldId, so the essential parameter semantics are covered.

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

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

The description uses a specific verb ('delete') and resource ('world'), and specifies the full scope of deletion ('all related entities, scenes, checkpoints and events'). This clearly differentiates it from siblings like update_world and create_world, making the tool's 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 clearly implies this is the tool for permanently removing an entire world, and the confirmation requirement is a concrete usage instruction. It does not explicitly name alternatives or state when not to use the tool, but the context is clear enough that an agent can identify the right invocation scenario.

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 annotation readOnlyHint=true indicates the tool is read-only, and the description does not contradict this (annotation_contradiction=false). The description adds behavioral context about what data is loaded (world framing, scene details), which goes beyond the annotation, but it does not disclose potential performance implications or the exact structure of the returned context. Given the read-only annotation, the bar is lowered, but the description could add more depth about the returned 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 concise and front-loaded with the core purpose, followed by a usage hint. Every sentence adds value, and there is no redundancy with the schema or annotations. It is appropriately sized 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?

Given the tool is a read-only context loader with a relatively simple input schema (one required param, one optional boolean), the description is fairly complete. It indicates the type of information returned (framing, scene, location, characters, plots) and the usage context. However, it does not explain the behavior of includeSecrets (e.g., whether it loads hidden plots or character secrets), which could be important for correct invocation. There is no output schema, but the description partially compensates by listing the content types. Minor gaps remain, but overall it is sufficient.

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

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

The input schema covers half of the parameters: worldId is described as a numeric ID from list_worlds or create_world, with exclusiveMinimum and maximum. However, includeSecrets lacks a description. The tool description does not explicitly explain the parameters, but given the 50% schema coverage, the description adds some context by implying that the loaded context might include secrets (from the parameter name). The description partially compensates for the missing 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 identifies the tool as loading world framing, current scene, location, characters, and plots, with a specific verb and resource. It distinguishes itself from the compact overview and from siblings like get_world_overview and get_recent_events by focusing on the current playable 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?

The description includes a clear usage hint: 'Use after the compact overview when continuing play.' This provides context for when to call the tool, though it does not explicitly mention alternatives or exclusions. It effectively instructs on the intended sequencing.

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

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

Annotations already declare readOnlyHint=true. The description adds meaningful behavioral context beyond that: newest-first ordering, compactness, backward pagination, checkpoint-based filtering, and the relationship to current context. No contradiction with annotations.

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

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

Two sentences with no wasted words. The core purpose is front-loaded, and the exclusion is stated immediately after the capabilities. 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?

With no output schema and low parameter documentation, the description leaves out important invocation details: return shape, what 'relevant events' means, how query filtering works, what includeSecrets does, and how pagination parameters interact. An agent would still have to guess at several 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?

Schema description coverage is only 17%, so the description must compensate for undocumented parameters. It mentions backward pagination and checkpoint filtering, which hints at beforeId and sinceCheckpointId, but it does not explain limit, query, includeSecrets, or pagination mechanics. This is insufficient for a 6-parameter tool with mostly undocumented 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 ('Read') and resource ('compact newest-first history') and explains the tool's purpose: showing how the authoritative current state developed. It also distinguishes itself from current context, which is a sibling tool, so an agent can tell them apart.

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

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

The description gives concrete usage context: backward pagination and events since a checkpoint. It also explicitly warns 'do not use it instead of current context,' providing a when-not. It does not name all alternative siblings or broader selection criteria, but the guidance 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds meaningful behavioral context: the latest checkpoint contains only playerRecap by default, and GM notes/secret records require explicitly authorized secret access. This goes beyond the annotation and clarifies what the tool actually returns.

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

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

Two sentences with no filler. The core purpose is front-loaded, and the important caveat about secret access is stated directly. Every sentence earns its place.

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

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

For a read-only preview tool with two well-documented parameters and no output schema, the description plus schema is sufficient for an agent to call it correctly. It could optionally describe the return shape, but that is not necessary given the compact nature of the tool and the existing annotations.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description reinforces includeSecrets' default behavior by explaining the default playerRecap-only content, but it adds no new parameter syntax, format, or additional semantic detail beyond what the schema provides.

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

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

The description states a specific verb and resource: 'Load a token-conscious save preview.' It also clarifies the default content (playerRecap only) and the secret-access requirement, which helps distinguish it from siblings like list_checkpoints and get_current_context, though it does not explicitly name alternatives.

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

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

The description implies usage for a compact, token-conscious preview and warns that secrets require authorized access, but it does not explicitly state when to use this tool versus siblings such as list_checkpoints or get_current_context. The context is present but the exclusion/alternative guidance 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?

Annotations already mark this as read-only (readOnlyHint=true), and the description adds meaningful behavior beyond that: results are ordered newest first, GM notes are excluded by default, and includeSecrets controls their visibility. It does not discuss rate limits or error conditions, but for a read-only list tool this is solid coverage.

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, zero filler. The core behavior ('player-safe checkpoint recaps newest first') is front-loaded, and the security-sensitive GM note caveat is placed immediately after. 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 read-only list with no output schema, the description covers the essential contract: what is listed, in what order, and under what conditions secret content appears. The only minor gap is the lack of explicit guidance on pagination, but 'newest first' plus the beforeId field make it inferable.

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 documents worldId and includeSecrets but leaves limit and beforeId undocumented (50% coverage). The description partially compensates by clarifying includeSecrets semantics ('in an authorized GM context') and implying cursor behavior via 'newest first', but it never explains how beforeId or limit affect the response.

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 action ('List'), the resource ('player-safe checkpoint recaps'), and adds ordering ('newest first'). It clearly distinguishes the read operation from siblings like create_checkpoint and apply_world_changes, though it does not explicitly name alternative tools to differentiate.

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

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

The phrase 'player-safe' and the note about 'authorized GM context' imply the player vs. gamemaster use case, but the description never explicitly says when to use this tool versus alternatives like get_recent_events or get_world_overview. The usage context is clear by implication, not by directive.

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

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

Annotations already declare readOnlyHint=true, so the description doesn't need to repeat that. It adds the behavioral detail that it never loads full world data, which is useful. However, it doesn't describe the return format or any pagination, but for a zero-parameter list tool this is acceptable.

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

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

Two short sentences with no waste. The key usage guidance is front-loaded, and the behavioral note is 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 zero-parameter, read-only list tool with no output schema, the description covers the essential usage and behavior. It could mention what 'compact' means or the return format, but it's adequate for an agent to call it correctly.

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

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

There are zero parameters, so the schema is trivially complete. The description adds the semantic that it returns compact entries, which is useful context beyond the empty schema. Baseline 4 for zero params is appropriate.

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

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

The description states a specific verb ('List') and resource ('compact save-game entries'), and distinguishes it from siblings by noting it never loads full world data. It doesn't explicitly name a sibling, but the purpose is clear.

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

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

It explicitly says to use this first in a new chat, which is a clear usage context. It doesn't mention alternatives or when not to use it, but the guidance is sufficient for a simple list 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 readOnlyHint annotation already signals that this is a safe read-only operation. The description adds useful context about neutrality and narrative use, but it does not disclose behavioral details such as whether min and max are inclusive, how count affects the result, or what distribution is used.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the boundary-setting exclusions are 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?

The tool is simple and read-only, so the description covers the core purpose well. However, the lack of output schema and parameter semantics leaves some ambiguity about return shape and bound inclusivity, making it adequate but not 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 description provides no explanation of the min, max, or count parameters. With 0% schema description coverage, the description was expected to clarify bounds inclusivity and count behavior, but it does not; it relies entirely on the self-explanatory property 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 verb ('Generate'), the resource ('random integers'), and the intended use case ('unbiased narrative decisions'). The second sentence explicitly distinguishes it from rules or dice systems, which removes ambiguity about 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?

The description provides a clear when-to-use signal: unbiased narrative decisions. It also gives an explicit when-not-to-use signal by stating it is not a rules or dice system, though it does not name a specific alternative tool.

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

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

Annotations declare readOnlyHint=true, and the description's words 'lookup' and 'search' are consistent with a read-only operation. However, the description does not disclose additional behavioral traits such as default pagination (limit=50), whether includeSecrets defaults to false, or how active filtering works. The annotation lowers the burden, but the description still adds limited 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 core idea ('Targeted lookup') with illustrative examples. It avoids filler, although for a tool with 8 parameters, a bit more structured parameter context would improve clarity without harming conciseness.

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

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

With 8 parameters, only 13% schema coverage, no output schema, and minimal annotations, the description leaves major gaps: return format, pagination limits, the role of query vs. name, how active and includeSecrets affect results, and what 'where a character is' means in terms of parameters. The examples are helpful but not enough for reliable invocation.

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

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

Schema description coverage is only 13% (only worldId has a description). The description's examples hint at worldId, kind, and locationId, but it does not explain the semantics of query, name, limit, active, or includeSecrets. Since the schema is mostly silent and the description does not compensate, agents will struggle to set parameters correctly.

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

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

The description states a specific verb ('search', 'lookup') and resource ('characters, locations, plots, notes and items'), and the example questions clarify the intended function. It is clearly distinct from sibling tools like list_worlds and get_world_overview, which are not targeted searches.

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 through examples ('all characters in a world', 'where a character is'), but it never explicitly contrasts with sibling read tools like get_current_context or get_world_overview. There is no 'when not to use' guidance, so the agent must infer the appropriate scenario.

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

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

No annotations are provided, so the description must carry the full burden. It discloses that the operation is 'compact' and that it does not permanently move characters, which adds context. However, it does not mention side effects, permissions, or reversibility. The disclosure is partial, hence a 3.

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

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

Two sentences with no redundancy; the core purpose and a key caveat are 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?

For a tool with 5 parameters and no output schema, the description is adequate but not complete. It clarifies the primary intent and the participant parameter, but does not specify return values, error conditions, or usage prerequisites. Given the tool's moderate complexity, a 3 is appropriate.

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

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

Schema description coverage is low (20%), so the description must compensate. The description clarifies that 'participants' means 'who is narratively present', which adds meaning beyond the bare parameter name. It does not explain all parameters, but the key one is addressed. Given low coverage, this is a strong contribution.

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

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

The description states a clear verb ('Record') and resource ('compact immediate scene'), and explicitly clarifies that it does not move every character permanently, which distinguishes it from potentially similar operations like apply_world_changes. However, it does not explicitly name sibling tools to differentiate further.

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 context that it records the 'immediate scene' and clarifies a limitation (does not move characters permanently), but it does not explicitly state when to use this tool versus alternatives like get_current_context or apply_world_changes. Usage guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It conveys that updates are 'durable' and that transient narration is out of scope, but it never states whether the update overwrites or merges existing fields, whether it is destructive, what the response looks like, or any prerequisites. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

Two short sentences with zero filler. The first sentence states the action and object, the second adds a meaningful boundary instruction. Every word earns its place, and the durable/transient distinction is front-loaded.

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

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

This is a mutation tool with no annotations, no output schema, and three undocumented parameters. The description is too thin to be complete: it omits return value behavior, update semantics (merge vs. overwrite), and any guidance on the content fields. An agent could call this correctly only by opening the schema and guessing at the meaning of the undocumented fields.

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 only 25% (only worldId is documented), and per the rubric the description must compensate for the three undocumented parameters (name, summary, description). The phrase 'durable framing' provides only loose thematic context and never maps to individual parameters, so an agent gets little help understanding what to put in name, summary, or 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 states a specific verb ('Update') and resource ('a world's durable framing'), and the 'durable' qualifier sets it apart from read-oriented siblings like list_worlds and get_world_overview. However, it does not explicitly differentiate itself from the 'apply_world_changes' sibling, whose name could plausibly describe the same operation, so it falls short of a 5.

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

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

The description gives one explicit exclusion: 'Do not record transient narration here,' which implies the tool is reserved for persistent lore rather than scene-level content. But it names no alternatives (e.g., set_current_scene or apply_world_changes for transient work) and provides no positive guidance on when this tool should be selected, leaving usage mostly implied.

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