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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Create a new ability.' It fails to mention required campaign context, side effects, idempotency, auth requirements, or what happens on success.

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 but under-specified; the single sentence merely restates the tool's name and purpose without adding value. True conciseness would front-load critical details like the required campaignId and the expected structure of data.

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 two required parameters, a nested data object, no output schema, and no annotations, this description is completely inadequate. An agent cannot determine what to pass for data, what campaignId refers to, or what a successful creation returns, making the tool effectively unusable from the description alone.

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

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

Schema description coverage is 0%, and the description provides no explanation of either parameter. The 'data' property is an untyped object with no defined shape, and 'campaignId' has no semantic meaning attached, leaving the agent unable to construct a valid request.

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 'Create a new ability' clearly states a specific action and resource, distinguishing it from get_ability, update_ability, delete_ability, and list_abilities. However, it offers no detail about what an ability is in this domain, so it lacks explicit differentiation from the many other create_* sibling tools.

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

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

No guidance is provided on when to use this tool versus alternatives like update_ability or create_character. The intended use case must be inferred entirely from the tool name, with no exclusions or conditions stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it only restates the creation operation already implied by the tool name. It does not mention persistence side effects, campaign association, permissions, validation, or return behavior.

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

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

The one-sentence description is short and readable, but the brevity is under-specification for a tool with two required parameters and a nested data object. It lacks enough substance to count as 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?

With no output schema, no annotations, and 0% schema description coverage, this one-line description is the agent's only guidance, and it explains nothing about required inputs, behavior, or success criteria. For a create operation with required campaignId and data, this is materially incomplete.

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

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

Schema description coverage is 0%, yet the description names neither campaignId nor data. An agent gets no clue that campaignId likely identifies the campaign to add the calendar to, or what shape the nested data object should take.

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 action ('Create') and a clear resource ('a new calendar'), so an agent can tell this tool creates a calendar as opposed to listing, updating, or deleting one. However, it mostly paraphrases the tool name and does not distinguish it from other create_* siblings such as create_timeline or create_event.

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

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

There is no guidance about when to use this tool versus list_calendars, update_calendar, delete_calendar, or related create tools. No prerequisites are mentioned, such as requiring an existing campaignId. The intended invocation context is left entirely to inference.

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

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

With no annotations, the description must carry the full behavioral burden, but it only states that a character is created. It does not disclose mutation/side effects, validation requirements, whether the creation is tied to a campaign, or any irreversible consequences.

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

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

The description is a single sentence with no filler or redundancy; it is concise and front-loaded. However, the extreme brevity leaves out details that would make the tool more usable.

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 mutation tool with no annotations, no output schema, and two utterly undocumented parameters, this description is far too incomplete. An agent has no information about the required nested data object, the meaning of campaignId, or expected behavior on success or failure.

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

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

Schema description coverage is 0% and the description adds no meaning to either parameter. 'Create a new character' does not explain what campaignId refers to or what shape the data object must take, leaving an agent unable to construct a valid call.

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 action (create) and resource (character), making the tool's basic function clear. It does not add scope details or differentiate from sibling create_* tools beyond the resource name, so it stops short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as update_character or when campaignId is required. The intended use is barely implied by the verb 'Create', but no context, prerequisites, or exclusions are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only restates that a creature is created and does not disclose what happens with the required campaignId/data, whether the operation is reversible, what response to expect, or any validation or permission concerns.

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 short and front-loaded with no filler, but it is closer to under-specification than effective concise documentation. Every word earns its place, yet the overall content is not appropriately sized for a tool with a nested data object and no annotations.

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 mutation tool with no annotations, no output schema, and an opaque nested data parameter, this description is inadequate. It names the resource and action but leaves almost all invocation details unspecified, so an agent cannot reliably construct a correct call.

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

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

Schema description coverage is 0%, and the description mentions neither campaignId nor data. The description adds no meaning beyond the schema's bare property names, leaving the agent unable to understand what data should contain or how campaignId relates to the new creature.

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

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

The description states a specific verb and resource: 'Create a new creature.' It is clear about the operation and entity, though it does nothing to differentiate itself from sibling create_* tools beyond the resource noun in its own name.

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

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

No guidance is given about when to use this tool versus alternatives, when not to use it, or what prerequisites exist. With many sibling create_* tools, an agent receives no routing help beyond the resource name itself.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that a new event is created, omitting side effects, required campaign context, permissions, idempotency, or data structure expectations.

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 but this is under-specification rather than effective conciseness. It omits essential information about required parameters and data structure, making the brevity a liability.

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 creation tool with a required nested object, no output schema, no annotations, and no parameter documentation. A single sentence restating the tool name is far from sufficient for an agent to safely invoke 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 description coverage is 0%, and the description does not mention either parameter. The bare schema types 'number' and 'object' give no meaning for campaignId or the nested data object, so an agent cannot construct a correct call.

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 'Create a new event' is essentially a restatement of the tool name. It identifies the action and resource but provides no additional specificity or differentiation from the many sibling create_* tools.

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

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

No usage context or alternative guidance is provided. An agent can only infer from the name that this tool creates an event, with no indication of when to prefer it over update_event, delete_event, or other creation tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Create a new family' discloses only that this is a creation operation and says nothing about side effects, required campaign context, validation behavior, or response format. This is a significant transparency gap for a mutation tool.

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

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

The description is short and front-loaded, but it is under-specified rather than usefully concise. It essentially restates the tool name and contributes no additional semantic value, so the brevity works against it.

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 two required parameters, a nested 'data' object, no output schema, and no annotations, the description is far too sparse to enable a confident invocation. An agent would not know what to put in 'data,' whether campaignId must reference an existing campaign, or what the API returns. The description provides only the high-level purpose, not enough to call the tool correctly.

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

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

Schema description coverage is 0%, and the description does not mention either parameter. 'campaignId' is nominally understandable as a campaign identifier, but 'data' is left as an opaque object with no indication of what fields or structure are expected. The description fails to compensate for the lack of schema detail.

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

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

The description states a clear verb and resource: 'Create a new family.' It clearly indicates a creation operation and distinguishes itself from the get_family, update_family, and delete_family siblings. However, it is a near-paraphrase of the tool name and adds no detail about what a family is or what creating one entails.

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

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

There is no guidance about when to use this tool versus alternatives, nor any mention of prerequisites such as needing an existing campaign. The only usage signal is the word 'create,' which is implied by the tool name itself. This is effectively no 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states that a new item is created, but does not explain the mutation's effects, side effects, required campaign context, validation behavior, or ownership implications.

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

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

The description is short, but it is under-specified rather than appropriately concise. It repeats the tool name's meaning and fails to earn its place by adding any decision-relevant information beyond the name.

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

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

Given the absence of annotations, an opaque nested parameter, and the large set of sibling CRUD tools, this description is insufficient for an agent to confidently select and correctly invoke the tool. It does not address what data should be supplied, how campaignId relates, or what the creation entails.

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

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

The input schema has 0% description coverage and the description adds no explanation for 'campaignId' or 'data'. In particular, the nested 'data' object is completely opaque, and the description provides no hints about its expected structure or relationship to the campaign.

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

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

The description uses a specific verb and resource ('Create a new item'), clearly identifying the operation as item creation. It is distinguishable from sibling create_* tools by resource type, though it offers no further differentiation or context about what an 'item' specifically entails.

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

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

There is no guidance about when create_item should be used instead of the many related create_* tools, nor are any prerequisites or contexts mentioned. The description is purely a statement of action with no usage direction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the mutation ('create a new journal') and says nothing about side effects, required ownership (campaignId), or what the response will be. This is minimally transparent and leaves the agent to infer the behavior of a create operation.

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

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

The description is short and front-loaded with the verb, with no wasted words. However, it is under-specified even for a simple tool, so the brevity is not a fully appropriate size and does more to obscure than to clarify.

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 two required parameters (one an undocumented nested object), no output schema, and no annotations, the tool needs a much richer description to be callable by an agent. The single sentence is nowhere near complete for deciding how to construct a correct request.

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

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

The input schema exposes campaignId and data with zero description coverage, and the description mentions neither parameter. The agent cannot tell what campaignId refers to, what shape data should take, or why both are required; the description adds no meaning beyond the raw schema.

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

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

The description 'Create a new journal' states a clear verb and resource, so an agent can identify the basic operation. However, it essentially paraphrases the tool name and gives no detail about what a journal is or what differentiates this create operation from the many other create_* 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?

There is no guidance on when to use this tool versus alternatives such as create_character, create_note, or update_journal, and no prerequisites or context for journal creation are given. The only usage signal is the bare infinitive 'Create,' which provides no strategic direction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only communicates that this is a write operation; it does not describe side effects, campaign scoping, validation, duplicate handling, or return behavior.

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

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

The description is short and front-loaded with no wasted words. However, the brevity is achieved by omitting substance rather than by condensing meaningful guidance.

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

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

Given two required parameters, a nested object, no output schema, and no annotations, the description is drastically incomplete. A usable definition would need to explain campaignId, the data payload shape, and what the tool returns.

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

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

Schema description coverage is 0%, and the description mentions neither campaignId nor data. The data parameter is an opaque object, so the agent cannot determine what fields or structure are expected.

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 is a near word-for-word restatement of the tool name: 'create_location' becomes 'Create a new location'. It is not misleading, but it adds no extra scope, detail, or sibling differentiation beyond simply repeating the operation and resource.

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

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

There is no guidance about when to use this tool versus updating or fetching an existing location, nor any mention of prerequisites such as needing a valid campaignId. Usage is only implied by the verb 'create'.

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

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

With no annotations provided, the description must carry the full behavioral disclosure burden, but 'Create a new map' only states the action. It does not mention side effects, permissions, failure modes, reversibility, or what happens on duplicate creation.

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 very short and contains no wasted words, making it concise. However, it is under-specified for a tool with a required nested object parameter and would benefit from more structure and 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 two required parameters including a nested object, no output schema, and no annotations, the description is severely inadequate. It fails to explain what 'data' should contain, why campaignId is needed, or what the operation returns, making it nearly impossible for an agent to invoke correctly.

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

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

Schema description coverage is 0% and the description does not mention either 'campaignId' or 'data' at all. The unstructured 'data' object is completely unexplained, so an agent has no idea what content to supply.

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 the specific action 'create' on the 'map' resource, which clearly separates it from get_map, update_map, delete_map, and list_maps. However, it lacks any scope or distinguishing detail beyond the resource name, so it doesn't fully clarify what a map is in this 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?

No guidance is provided about when to use this tool versus any of the many sibling create_* tools, and no prerequisites such as an existing campaign are mentioned. The description offers no alternatives, exclusions, or contextual hints.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. 'Create a new note' only restates the action and reveals nothing about persistence, side effects, required permissions, or return behavior. It adds no informative detail beyond the tool name.

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

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

The text is brief, but that brevity reflects under-specification rather than effective conciseness. A single uninformative sentence that fails to address the required parameters is not appropriately sized for a tool of this 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 two required parameters, no output schema, and no annotations, the description is severely incomplete. It omits the apparent relationship between notes and campaigns, the structure of data, and any invocation context. An agent would be guessing at critical input requirements.

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

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

Schema description coverage is 0%, and the description does not explain campaignId or the 'data' object at all. An agent cannot determine what the data object should contain or how it relates to the campaignId parameter. The description adds zero meaning beyond the raw schema.

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

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

The description states a specific verb ('create') and resource ('note'), which distinguishes it from update_note/delete_note and from create tools for other resource types. It lacks any mention of campaign scoping, but the core purpose is clear enough.

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

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

There is no guidance on when to use create_note versus get_note/update_note/delete_note, nor any mention of prerequisites such as needing an existing campaign. The description provides no context for selecting 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it merely restates the tool name. It does not mention that this is a write operation tied to a campaign, how the data object is used, whether the operation is idempotent, or what effect it has on existing resources.

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

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

The description is short, which is good for conciseness, but it is under-specified rather than efficiently complete. It adds no value beyond the tool name and provides no structure for the required inputs.

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

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

The tool has no annotations, no output schema, a nested data object, and zero schema description coverage. A one-line restatement of the tool name is far too little for an agent to correctly construct a call or understand the expected request shape.

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

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

Schema description coverage is 0%, and the description contains no parameter information. It does not explain that campaignId identifies the campaign or that data contains the organization payload, leaving the agent without meaningful guidance for two required parameters.

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

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

The description states a clear action and resource: 'Create a new organization'. It is unambiguous about what entity is being operated on, but it does not actively distinguish itself from the many other create_* sibling tools beyond relying on the resource name.

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

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

The description implies it should be used when creating a new organization, especially in contrast with update_organization and delete_organization. However, it gives no explicit context, prerequisites, or guidance about when to choose 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only conveys that the tool creates a quest and provides no information about side effects, required parent entity, validation, permissions, or error behavior. The description does not contradict any annotation because none exist.

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

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

The description is a single short sentence with no redundant wording, but it essentially restates the tool name and adds no substantive information. This is under-specification rather than effective conciseness.

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

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

The tool requires a campaignId and a nested data object, has no output schema, and has no annotations. The description is far too sparse to allow an agent to call this tool correctly; it gives no indication of the data structure, the relationship to a campaign, or what a successful response looks like.

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

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

Schema description coverage is 0%, and the description does not mention either parameter (campaignId or data). Since data is a nested object and campaignId is a required number, the agent receives no help understanding what values to provide or what the data object should contain.

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 action ('Create') and resource ('quest'), which clearly distinguishes it from read/update/delete siblings. However, it adds no additional qualification about what a quest is or how it relates to campaigns, so it is clear but minimal.

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

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

No guidance is provided on when to use this tool versus update_quest or delete_quest, nor is there any mention that a campaign must already exist. The agent must infer usage entirely from the tool name and sibling names.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely states 'Create a new race' and says nothing about side effects, permissions, idempotency, required campaign context, or what happens on success or failure.

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 but it is under-specified rather than concise. The single phrase earns its place only by restating the function name, offering no substantive information to 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?

Given a required nested 'data' object, no output schema, no annotations, and zero schema descriptions, the description fails to provide basic invocation context. An agent cannot determine what data structure to send or what the response will be.

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

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

Schema description coverage is 0% and the description adds no meaning to the parameters. The required 'data' object and 'campaignId' are completely undocumented, so an agent has no idea what to pass.

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 'Create a new race' simply restates the tool name 'create_race' with no additional detail. It identifies the action and resource, but is purely tautological and does not differentiate this tool from the many other create_* siblings beyond the embedded resource name.

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

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

No guidance is provided on when to use this tool versus alternatives. With a large sibling set including get_race, update_race, delete_race, and other create_* tools, the description offers no context or exclusionary conditions.

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

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

With no annotations, the description bears the full burden of behavioral disclosure, but it only states the operation type (create) without mentioning side effects, requirements, or what happens to the nested data object. It is not misleading, but it provides no meaningful transparency beyond the action itself.

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

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

The description is short, but brevity here is under-specification rather than effective conciseness: the single sentence merely restates the tool name and provides no useful details. It is appropriately front-loaded but does not earn its place with additional value.

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

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

For a creation tool with two required parameters, one of which is an opaque nested object, and no output schema or annotations, the description is far too thin. An agent cannot determine what data to provide, how campaignId is used, or what a successful timeline creation entails.

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

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

Schema description coverage is 0%, so the description must compensate by explaining what campaignId and data mean; it addresses neither parameter. The nested data object is completely unexplained, leaving the agent without enough information to construct a valid call.

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 merely restates the tool name ('Create a new timeline' adds no information beyond create_timeline), so it is a tautology rather than a distinguishing definition. It identifies the verb and resource but does not clarify what a timeline is or how it differs from other timeline-related tools.

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

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

There is no guidance on when to use this tool versus alternatives such as update_timeline or delete_timeline, or whether any prerequisites apply. The correct usage must be inferred entirely from the tool name and the CRUD pattern.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only says 'delete', which implies a destructive action, but does not state whether deletion is permanent, idempotent, cascading, or what happens when the ability does not exist.

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 wastes no words, but it is under-specified rather than usefully concise. It is essentially a restatement of the tool name and provides no structural information about parameters or usage.

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

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

For a destructive tool with no annotations, no output schema, and undocumented parameters, the description is insufficient. It lacks any mention of irreversibility, side effects, or related lookup tools, leaving an agent without enough context to call it safely.

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

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

Schema description coverage is 0%, and the description does not mention or explain either parameter. The presence of 'id' and 'campaignId' as bare numbers is ambiguous; the description adds nothing to help an agent understand their roles or format.

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

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

The description 'Delete an existing ability' is a direct restatement of the tool name 'delete_ability'. It names a verb and a resource, but adds no information beyond what the name already conveys, and does not distinguish it from the many sibling delete_* tools.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_ability or update_ability. There are no stated prerequisites, exclusions, or suggestions for verifying the ability before deleting.

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

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

With no annotations, the description must disclose behavioral traits, but it only says 'Delete an existing calendar.' It does not state whether the deletion is permanent, irreversible, or whether it cascades to associated events or other data. For a destructive operation, this lack of transparency is a significant gap.

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

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

The description is a single sentence with no filler words, and the core action is front-loaded. It is concise and easy to parse, though the brevity contributes to the lack of context in other dimensions. It earns its place but could have been expanded with minimal cost.

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

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

For a destructive tool with no annotations, no output schema, and two undocumented parameters, this description is insufficient. It does not explain how to identify the target calendar, what the consequences of deletion are, or what the expected response is. An agent would need to guess or consult other sources to call this correctly.

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

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

Schema description coverage is 0%, and the description provides no information about the parameters 'id' and 'campaignId.' An agent cannot determine which ID is which or how they relate to the calendar being deleted, so the description adds no meaning beyond the raw parameter 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 a specific verb ('Delete') and resource ('calendar'), which distinguishes it from sibling tools like create_calendar, update_calendar, get_calendar, and list_calendars. It is straightforward and leaves no doubt about the tool's core function, though it adds no detail beyond the operation itself.

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

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

There is no guidance on when this tool should be used versus alternatives, no mention of prerequisites (e.g., needing the calendar ID and campaign ID), and no exclusion cases. The description simply names the action without contextualizing when it is appropriate or when a different tool might be preferable.

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

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

With no annotations provided, the description must carry the full behavioral burden. It discloses that the action deletes a character, but it does not state whether the deletion is permanent, whether it cascades to associated data, whether it requires special permissions, or what happens after deletion.

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

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

The description is a single concise sentence with no redundant wording. However, it is under-specified: it basically restates the tool name and omits important context, so the brevity comes at the cost of usefulness.

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

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

For a destructive tool with no output schema and no annotations, the description is not complete enough. It fails to explain required identifiers, deletion semantics, side effects, or any safety considerations, leaving an agent under-informed before 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 0%, so the description must compensate, but it adds no parameter-level meaning. It implies that 'id' identifies the character, but 'campaignId' is left completely unexplained, leaving the agent to guess how the campaign scope affects the deletion.

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: 'Delete an existing character'. It clearly communicates the operation and distinguishes it from sibling tools like create_character, update_character, and get_character, though it does not explicitly contrast itself with them.

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

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

There is no guidance on when to use this tool versus alternatives, or any mention of requirements such as the character being associated with a specific campaign. The intended use is only implied by the verb 'Delete' and the resource name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly indicates a destructive mutation, but says nothing about whether deletion is permanent, what happens if the creature does not exist, or whether related data is affected. This is a significant gap for a delete operation.

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

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

The description is very concise with no wasted words, but it is under-specified. It earns a middle score because brevity is present, but the structure does not include important context that an agent would benefit from.

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

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

Given that there is no output schema and no annotations, the description is not complete enough for a delete operation. It does not explain the required campaign context, the effect of the operation, error behavior, or what the agent should expect after a successful deletion.

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

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

Schema description coverage is 0%, and the description provides no explanation of the 'id' or 'campaignId' parameters. The parameter names are somewhat self-explanatory, but the description does not clarify which id refers to the creature, why campaignId is required, or how the two parameters relate.

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 action ('Delete') and a specific resource ('existing creature'), clearly distinguishing it from get_creature, create_creature, update_creature, and list_creatures. It is concise and unambiguous, though it adds little beyond the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or consequences. It is implied that deletion is the right operation when a creature should be removed, but the description does not make the usage context 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. 'Delete' conveys that this is a destructive operation, but the description does not state whether deletion is permanent or irreversible, whether it cascades to related data, whether special permissions are required, or what happens if the event does not exist. There is no contradiction with annotations since none are present, but disclosure is minimal.

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

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

The description is five words with zero filler and the core action is front-loaded. It is efficiently brief, though the brevity is partly a product of under-specification rather than a deliberately compact rich definition.

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

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

For a destructive tool with two undocumented parameters, no annotations, and no output schema, this description is inadequate. It fails to clarify parameter semantics, permanence of deletion, or error behavior, leaving an agent unable to confidently invoke the tool correctly despite the simple interface.

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

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

Schema description coverage is 0%, so the description must compensate by explaining what 'id' and 'campaignId' mean and how they relate. It does neither — the description mentions no parameters at all. An agent cannot determine what values to supply or whether campaignId scopes the id.

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

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

The description uses a specific verb ('Delete') and a clear resource ('event'), which immediately distinguishes it from sibling tools like create_event, update_event, get_event, and list_events. The word 'existing' also correctly scopes the action to pre-existing records. It is slightly minimal, but the purpose is unambiguous.

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

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

No guidance is given about when to use this tool versus alternatives such as update_event, nor about prerequisites like the event having to exist in the given campaign. The only usage signal is implicitly derived from the verb 'delete,' which does not constitute explicit usage guidance.

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

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

With no annotations, the description carries the burden of disclosing behavior. It only restates the delete operation and does not mention irreversibility, cascading effects, authorization needs, or whether deletion is scoped by campaignId.

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

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

The description is a single short sentence with no filler, but it is under-specified rather than appropriately concise. It omits parameter roles and behavioral context that are essential for correct invocation.

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

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

For a two-parameter destructive operation with no output schema and no annotations, this description is insufficient. The agent cannot determine how to populate campaignId or what consequences deletion has, despite the overall CRUD context provided by sibling tool names.

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

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

Schema description coverage is 0% and the description provides no meaning for the id or campaignId parameters. Both are bare number fields, so the agent cannot tell which is the family identifier and which is the campaign scope from the description alone.

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

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

The description states a clear verb and resource: it deletes a family. It does not add detail that distinguishes it from sibling delete tools beyond the resource name, but for a CRUD delete the purpose is unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as delete_character or update_family. The description does not mention required context such as campaignId or any preconditions, so usage context is left entirely 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. 'Delete' implies destructive mutation, but the description does not state whether deletion is permanent, whether related records are affected, or whether special permissions are required. This is a significant gap for a destructive operation.

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

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

The description is concise and to the point, but it is under-specified rather than efficiently informative. It earns a middle score because there is no wasted text, yet the brevity omits essential 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?

With no annotations, no output schema, and zero parameter documentation, the tool requires more context than a one-sentence description provides. The description is complete only for the most trivial understanding of the operation and lacks details about response behavior, side effects, or parameter semantics.

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

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

Schema description coverage is 0%, and the description names neither parameter. The schema shows two numbers (id and campaignId) but the description does not explain that both are required or clarify the relationship between them (e.g., campaignId scopes the item). Because coverage is zero and the description adds nothing, it fails to compensate.

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 ('Delete') and resource ('existing item'), so an agent knows the basic operation. However, it does not distinguish this from delete_character, delete_location, or other delete_* siblings, and 'item' could be ambiguous without the sibling list context. It is minimally adequate but lacks specificity about which sibling it complements.

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

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

There is no guidance on when to use this tool versus alternatives like delete_character or delete_note. The description simply states what it does without any context, prerequisites, or exclusions. An agent must infer usage purely from the tool name and resource type.

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

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

No annotations are provided, so the description carries the full burden. 'Delete an existing journal' confirms the destructive nature but adds no detail about irreversibility, cascading effects, or failure behavior. The word 'existing' weakly implies the journal must be present, but this is minimal for a destructive operation.

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

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

A single five-word sentence with no filler. The verb 'Delete' leads, followed by the resource. It is appropriately concise for a simple CRUD operation, though it sacrifices explanatory content for brevity.

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

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

For a low-complexity delete tool with no output schema and no annotations, the description states the core action but leaves parameter explanations and behavioral caveats unaddressed. An agent cannot determine the role of campaignId or know whether deletion is reversible. The description is not complete enough for an unassisted agent to invoke the tool with confidence.

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 only numeric names id and campaignId with no descriptions, and the description adds no parameter information. The parameter names suggest id identifies the journal and campaignId scopes it, but the description does not clarify their roles or why both are required. With 0% schema description coverage, the description should compensate but does not.

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

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

The description 'Delete an existing journal' clearly identifies the action (delete) and resource (journal), making it easy to distinguish from create/update/get journal siblings. It adds the qualifier 'existing', which hints that the journal must already exist. However, it relies entirely on the verb for differentiation and does not add scoping or consequence detail.

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

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

Usage is implied: use this tool when a journal needs to be deleted. There is no explicit when-to-use guidance, nor mention of conditions, prerequisites, or alternatives. It also does not note that deletion is permanent or that campaignId must correspond to the journal's campaign.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It indicates the destructive nature of the operation but does not mention whether deletion is permanent, whether it cascades to related data, what happens if the location does not exist, or whether any permissions are required.

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

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

The description is a single, front-loaded sentence with no redundant words. Every word earns its place for a simple CRUD deletion tool.

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

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

Although the tool is simple, the description omits important context: return behavior, error cases, side effects, and the relationship between the two required parameters. With no output schema and no annotations, an agent cannot fully predict the outcome of invoking this tool.

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

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

Schema description coverage is 0%, so the description must compensate for the two undocumented parameters. It provides no explanation of what 'id' and 'campaignId' represent, how they relate to the deletion, or which is the location identifier. The description adds no meaning beyond the raw schema 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 uses a clear verb ('Delete') and a specific resource ('existing location'), which states the operation unambiguously. It distinguishes the tool from its siblings (create, update, get, list) even though it follows the same pattern as other delete_* tools.

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

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

No guidance is given about when to use this tool versus alternatives such as update_location or delete_character. The description simply states the action with no context, exclusions, or mention of prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the destructive action but does not mention whether deletion is permanent, reversible, or has cascading effects on associated data. This lack of detail is a significant gap for a delete operation.

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

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

The description is extremely concise with no wasted words. However, it is too sparse to fully serve its purpose, so while compactness is praiseworthy, the extreme brevity slightly reduces the score.

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

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

For a destructive operation with no annotations and no output schema, the description is under-specified. It fails to convey parameter semantics, side effects, or any cautionary context. An agent calling this tool would have little idea what consequences to expect beyond 'deleting a map'.

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

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

Schema description coverage is 0%, and the description 'Delete an existing map' explains nothing about the required parameters 'id' and 'campaignId'. The agent is left to guess which identifier targets the map and what the campaignId is used for, so the description adds no value beyond the raw schema.

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

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

The description uses a specific verb ('Delete') and resource ('map'), clearly distinguishing this from sibling tools like create_map, update_map, and get_map. It also notes the map must already exist ('existing'), which adds useful scope.

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

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

No guidance is provided on when to use this tool versus alternatives, or any prerequisites such as the map needing to exist or be deletable. The intended usage is only implied by the verb 'Delete'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete an existing note' conveys that this is destructive, but it does not state whether deletion is permanent, what happens if the note does not exist, or any 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 a single short sentence with no filler or repetition. The core message is front-loaded and easy to parse.

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

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

For a tool with no annotations, no output schema, and zero parameter documentation, this description is too thin. It leaves parameter semantics, deletion behavior, and return value unspecified, making it only minimally usable.

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

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

Schema description coverage is 0%, and the description adds no meaning for the two required parameters. The role of campaignId is entirely unexplained, and the description does not clarify how id and campaignId relate to the deletion 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 uses the specific verb 'Delete' with the resource 'note', making the tool's action and target unambiguous. It is clearly distinct from sibling tools like create_note, update_note, get_note, and list_notes.

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

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

The description implies this tool is for deleting an existing note, but it gives no explicit guidance on when to choose it over alternatives or any exclusions. There is no mention of prerequisites, such as needing both the note id and campaignId.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Delete' which implies destructive action, but it does not disclose irreversibility, cascading effects, permissions required, or consequences for related data.

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

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

The description is extremely concise and front-loaded, with no unnecessary words. However, it is under-specified: conciseness comes at the expense of essential context about parameters and behavior.

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

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

The tool is simple, with only two parameters and no output schema, but the description is too sparse to be complete. The role of campaignId is completely unexplained, and no behavioral or safety context is provided, making this insufficient for confident 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 0%, and the description provides no explanation of the two required parameters, id and campaignId. The agent is left without any understanding of what these parameters represent or how they relate, which is a critical gap.

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

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

The description clearly states the action ('Delete') and the resource ('an existing organization'), making the core purpose immediately understandable. It does not explicitly differentiate from sibling delete tools, but the resource name itself provides sufficient distinction.

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

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

No guidance is given about when to use this tool versus alternatives, such as update_organization or get_organization. There is no mention of prerequisites, contexts, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete' implies a destructive, likely irreversible action, but the description does not state this, mention any cascading effects, permission requirements, or what happens when the quest is not found. This is a significant gap for a mutation tool.

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

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

The description is one short sentence with no filler or redundant phrases. It is appropriately front-loaded with the action and resource. However, it is almost too sparse, since it sacrifices useful parameter context for brevity.

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

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

For a tool with two required parameters, zero schema description coverage, no output schema, and no annotations, the description is not complete enough. It establishes the operation but fails to clarify the role of campaignId versus id, the destructive nature of the action, or any expected return behavior. An agent would need additional context to call this tool confidently.

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

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

Schema description coverage is 0%, and the description provides no information about what 'id' or 'campaignId' mean, how they relate, or which one identifies the quest. The agent is left with only the raw schema, which gives types and required status but no semantic meaning. The description adds no value beyond the schema.

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

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

The description uses a specific verb ('Delete') and a clear resource ('a quest'), making the operation unmistakable. It also implies the target must already exist, which distinguishes it from create_quest. Among the siblings, the verbs cleanly separate delete_quest from get_quest, update_quest, create_quest, and list_quests.

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

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

There is no guidance about when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or conditions such as 'use delete_quest only when the quest exists' or 'use update_quest to modify instead.' The agent must infer usage entirely from the tool name and sibling list.

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

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

There are no annotations providing safety context, so the description carries the full burden. 'Delete an existing race' indicates a destructive action, but it does not disclose irreversibility, cascading effects, required permissions, or what happens after deletion.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and easy to parse, though the brevity comes at the cost of missing behavioral and parameter details captured in other dimensions.

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

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

For a destructive operation with no annotations and no output schema, the description is too thin. It fails to explain the role of campaignId, whether deletion is permanent, or any constraints or side effects. An agent would need to infer critical context from the tool name and sibling tools.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. While 'id' and 'campaignId' are somewhat self-explanatory from their names, the description adds no meaning about which race is being deleted or why campaignId is required.

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 a specific resource ('race'), making the tool's purpose immediately clear. It distinguishes itself from sibling tools like get_race, create_race, update_race, and list_races without requiring additional 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?

No guidance is given about when to use this tool versus alternatives such as update_race or get_race. The usage is only implied by the verb 'delete' and the tool name; there is no mention of prerequisites, exclusions, or alternative tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete' signals a destructive operation, but it does not mention permanence, whether deletion cascades to related data, what happens if the timeline does not exist, or any required permissions. This is a significant transparency gap for a mutation tool.

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

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

The description is a single concise sentence with no fluff or repetition. It is front-loaded with the core action and target resource, so it is 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?

For a simple two-parameter delete operation, the description is minimally viable but leaves gaps. It does not explain the relationship between campaignId and id, define success/failure behavior, or mention whether the delete is reversible. Without annotations or an output schema, more context would help.

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

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

Schema description coverage is 0%, and the description adds no meaning to the parameters. It does not explain that 'id' is the timeline identifier or that 'campaignId' scopes the deletion to a campaign. The agent must rely entirely on 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 states a specific verb ('Delete') and resource ('existing timeline'), so an agent can tell it deletes timelines rather than creating or updating them. However, it offers no detail that distinguishes it from the many sibling delete_* tools beyond the resource name.

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

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

There is no guidance on when to use this tool versus alternatives such as delete_character or delete_event. The intended use is only implied by the resource name, and no exclusions, prerequisites, or alternative recommendations are provided.

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

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

No annotations are present, so the description must carry the behavioral disclosure burden. 'Get details' implies a read operation, but the description does not mention response contents, campaign scoping, side effects, or error behavior.

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

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

The description is short with no filler and leads with the main verb, but it is so sparse that it borders on under-specification rather than effective concision. There is no structural separation or additional useful 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?

For a tool with no output schema, no annotations, and 0% parameter coverage, the description is insufficiently complete. It does not explain what details are returned, why campaignId is required, or how this tool relates to sibling lookup tools.

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

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

Schema description coverage is 0%, and the description adds no meaning to either parameter. The agent is not told that campaignId is likely a scoping identifier and id is the ability identifier, nor what value shape or constraints apply.

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

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

The description uses a specific verb ('Get') and resource ('ability') and implies fetching details for one ability, which is distinguishable from list_abilities and create/update/delete siblings. However, it does not explicitly explain how it differs from other get_* tools beyond the resource name.

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

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

There is no guidance on when to use this tool or when to prefer alternatives such as list_abilities or search. The description gives no context like 'use this after obtaining an ability ID' or 'use list_abilities to find IDs first.'

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Get details of a calendar' and gives no information about read-only guarantees, not-found behavior, permissions, or response shape. The verb 'Get' weakly implies a read operation, but that is not sufficient for 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 brief, front-loaded, and free of filler. However, it is so minimal that it sacrifices informative content, making it under-specified rather than effectively 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?

With two required parameters, no annotations, and no output schema, the description should explain how campaignId and id relate to retrieving a calendar. It does not mention the returned data, error cases, or usage context, leaving a significant completeness 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 0%, and the description adds no explanation of what campaignId or id mean. 'id' can be guessed as the calendar identifier from context, but campaignId's role is completely unexplained, leaving a factual gap in how to call the tool 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 uses a specific verb ('Get') and a specific resource ('calendar'), which is enough to distinguish it from list_calendars and create/update/delete_calendar siblings. However, it does not specify what 'details' includes, so it is clear but not maximally precise.

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

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

There is no guidance about when to use get_calendar versus list_calendars or other get_* tools. The agent must infer usage from the tool name and schema rather than being told the appropriate context or alternatives.

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

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

With no annotations, the description must carry the behavioral burden. The verb 'Get' implies a read-only operation, and the description is consistent with that, but it adds no additional behavioral context such as error conditions, permission requirements, or response nature. For a simple read tool this is adequate but minimal.

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

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

The description is a single short sentence with no filler or redundant phrases. It is front-loaded with the key information ('Get details of a character') and every word contributes to its meaning. Conciseness is excellent for a simple tool.

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

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

For a tool with two required parameters, no output schema, and no annotations, the description is too sparse. It does not explain parameter semantics, what the return value looks like, or how it differs in use from list_characters. An agent would need to infer critical details about how to call this correctly.

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

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

Schema description coverage is 0%, so the description should compensate by explaining what 'id' and 'campaignId' mean. It only mentions 'character', which hints that 'id' is the character ID, but 'campaignId' is left completely unexplained. The description does not add enough meaning beyond the parameter 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 'Get details of a character' uses a specific verb ('Get') and identifies the resource ('character'), clearly distinguishing it from sibling tools like get_quest or get_location. It is unambiguous and not a tautology, though it doesn't elaborate on what 'details' includes, which prevents a top score.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_characters or search. It does not state that this tool should be used when a specific character ID is already known, nor does it mention any exclusions or prerequisites. This is a clear gap.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states 'Get details of a creature' and gives no information about authentication requirements, not-found behavior, permissions, or whether campaignId scoping affects results.

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 short and contains no fluff, but it is under-specified rather than appropriately concise. A single clause for a tool with two required parameters and no output schema leaves important information out.

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 simple retrieval tool, but with no annotations, no output schema, and a bare description, there is no explanation of what 'details' includes or what the response looks like. The description is not complete enough for an agent to know what to expect or how to handle edge cases.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters, but it does not mention id or campaignId at all. While the parameter names are somewhat self-explanatory, the description adds no information about their relationship, requiredness, or expected format beyond what the schema already shows.

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

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

The description uses a specific verb ('Get') and resource ('creature'), clearly identifying the operation and distinguishing it from sibling tools like get_quest or get_item. However, 'details' is vague and does not specify what fields or scope are included.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_creatures or search. It is implied that this tool retrieves a single creature by ID, but no explicit context, prerequisites, or exclusions are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Get details.' It does not state that the operation is read-only, whether authorization or campaign context is required, what response format to expect, or any side-effect profile.

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

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

The description is brief but under-specified. 'Get details of a event' has a grammar error and provides no useful structure or distinguishing information; it is not appropriately sized for a tool with two required parameters and many siblings.

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

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

The tool has no output schema, no annotations, two required parameters, and numerous sibling tools, yet the description offers only a near-tautology. There is not enough contextual information for an agent to reliably select and invoke this tool correctly.

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

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

Schema description coverage is 0%, and the description does not mention or explain the two required parameters, id and campaignId. While the parameter names are somewhat self-explanatory, the description fails to compensate for the complete lack of schema descriptions.

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

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

The description 'Get details of a event' is essentially a tautology of the tool name get_event. It adds only the word 'details' and does not specify what is included, how it is scoped, or how it differs from other get_* sibling tools.

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

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

There is no guidance about when to use get_event versus list_events or any other sibling tool. No alternatives, exclusions, or usage conditions are mentioned, so an agent must infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden. 'Get details' implies a read-only retrieval, but it discloses nothing about the return payload, required scoping by campaign, or error/authorization behavior, leaving important behavioral context missing.

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

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

The description is a single short sentence with no filler, but it is too under-specified to be considered appropriately sized. It conveys the basic action without any informative context, landing between efficient and merely skeletal.

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 getter with no output schema, no annotations, and no parameter documentation, the description is incomplete. An agent can guess that it retrieves a family, but not what data will come back or how the two required identifiers are meant to be used.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. The names 'id' and 'campaignId' are suggestive, but the description does not clarify that id likely refers to the family ID or why campaignId is required, so it fails to compensate 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 uses a clear verb-resource pair ('Get details of a family'), so an agent can tell this is a read operation for a single family. It is somewhat generic and does not explicitly differentiate it from other get_* siblings beyond the resource name, so it falls short of a 5.

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

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

No guidance is given about when to call get_family instead of list_families, search, or other get_* tools. The intended use is only weakly implied by the verb and resource, with no exclusions or alternatives mentioned.

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

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

With no annotations, the description must carry the behavioral transparency burden, but it only says 'Get details'. It does not disclose expected response shape, error behavior (e.g., not found), authentication needs, or side effects, though 'Get' does imply a read-only operation.

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

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

The description is very short and front-loaded, with no fluff. However, it is under-specified and contains a grammatical error ('a item'), so it is not a well-crafted concise description that earns its place through substance.

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 two required parameters, no output schema, and no annotations, the description is too minimal to be complete. It does not mention why campaignId is needed, what 'details' includes, or any behavior around missing or invalid identifiers, so an agent cannot reliably invoke it with full confidence.

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

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

Schema description coverage is 0% and the description adds no meaning to the parameters. The required campaignId and id are both undocumented, and the description does not explain their relationship or how they should be used to fetch the item.

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 ('Get') and resource ('item'), so an agent can infer this is a read operation for a single item. It is not a tautology and is distinguishable from siblings like list_items and get_character by naming the item resource. However, it does not explicitly differentiate itself from similar get_* tools or clarify scope beyond 'details'.

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

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

The description gives no guidance on when to use this tool versus list_items, search, or other retrieval tools. There is no mention of prerequisites, campaign context, or exclusions, leaving the agent to guess when get_item is appropriate.

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

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

No annotations are present, so the description must carry the behavioral disclosure burden, but it only restates that the tool retrieves details. It does not clarify read-only behavior, response contents, error behavior, or campaign scoping beyond the word 'Get'.

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 six-word description has no redundancy and is easy to scan. However, it is under-specified relative to the missing parameter and context information, so the brevity comes at the cost of usefulness.

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 two required parameters, no schema-level parameter descriptions, no output schema, and no annotations, this description leaves too much implicit. An agent cannot reliably determine what the parameters mean, what the returned details look like, or when this tool is preferable to the list/search variants.

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

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

Schema description coverage is 0%, and the description does not explain either required parameter. The word 'journal' gives minimal context for interpreting 'id', but 'campaignId' and the relationship between the two IDs are left completely unexplained.

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 action ('Get details') and resource ('a journal'), which clearly identifies this as the singular retrieval tool for journals. It does not explicitly contrast with siblings like list_journals, but the singular phrasing and 'details' make 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?

There is no guidance about when to use this tool versus list_journals, search, or the other journal CRUD operations. It also does not state prerequisites like needing an existing journal id and campaignId, leaving usage decisions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, yet 'Get details of a location' adds nothing beyond the read-only implication already in the name. It doesn't state behavior for unknown IDs, whether campaignId scopes access, or what the response contains. There is no annotation contradiction, but also no behavioral context beyond the verb itself.

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

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

A single five-word sentence with no filler, front-loaded with the verb and resource. The structure is clean and scannable, though the brevity borders on under-specification — concision is achieved by omitting content rather than distilling it, which is why it doesn't earn a 5.

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

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

For a tool with 2 required parameters (one non-obvious: campaignId), zero schema parameter descriptions, no output schema, and no annotations, a five-word description is incomplete. The response format, the role of campaignId, and the difference from list_locations are all left to inference; the sibling list hints at a uniform CRUD pattern but the description never confirms 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 description coverage is 0%, so the description must compensate, but it names neither parameter. The phrasing 'of a location' weakly implies id is the location identifier, which is already obvious from the tool name, while the required campaignId parameter remains completely unexplained — an agent cannot tell whether it is a scoping key, a tenant identifier, or an authorization token.

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

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

The description uses a specific verb ('Get') and names the resource ('location'), so the core action is clear and it can be distinguished from get_quest/get_character by resource name. However, it doesn't explicitly differentiate from list_locations or clarify what 'details' means versus list output; an agent must rely on the get_/list_ naming convention to infer single-entity retrieval.

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

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

No guidance is provided on when to use get_location versus list_locations, search, or the adjacent get_X tools. There are no stated prerequisites, exclusions, or alternative routing conditions — the agent must infer the call context entirely from the sibling list and parameter names.

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

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

No annotations are provided, so the description carries the full burden. It only restates that the tool gets map details and adds no information about return shape, read-only behavior, pagination, or error conditions. This is minimally transparent beyond the operation name.

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, but it does not earn its place because it adds no information beyond the tool name. It is under-specified rather than appropriately 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 simple get tool with two required parameters and no output schema, the description is incomplete. It does not clarify the role of campaignId, how to supply the IDs, or what kind of details will be returned, leaving important context to guesswork.

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

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

Schema description coverage is 0%, and the description does not explain the meaning of id or campaignId. The agent is left to infer that id refers to the map and campaignId to the campaign, which is not stated anywhere.

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

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

The description 'Get details of a map' clearly states a specific verb and resource. It does not explicitly differentiate this tool from sibling get_* tools, but the target resource is unambiguous.

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

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

No guidance is provided about when to use this tool versus list_maps or other get_* tools. The description only implies that it is used when map details are desired, but offers no exclusions or 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?

No annotations are provided, so the description carries the burden of indicating behavior. 'Get details' clearly implies a read-only retrieval, but the description says nothing about response format, error behavior, or whether authentication/scoping beyond campaignId is needed.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It is appropriately sized for a simple getter tool.

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

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

For a simple two-parameter getter, the definition is minimally adequate: an agent can identify the action and required inputs. However, the absence of an output schema, annotations, and any parameter description leaves some ambiguity around the exact return value and ID semantics.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. Although 'id' and 'campaignId' are somewhat self-explanatory from their names, the description fails to state the relationship between them or what values are expected, which is a gap at this coverage level.

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

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

The description uses a specific verb ('Get') and resource ('note'), making the core purpose clear. It also implicitly distinguishes itself from list_notes and search, though it doesn't explicitly state what 'details' includes.

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

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

The description gives no guidance on when to use this tool versus alternatives like list_notes or search. There are no stated conditions, exclusions, or references to sibling tools, so an agent must infer usage entirely from the name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'get details', which implies a read operation, but it does not disclose what happens on missing resources, whether any authentication or campaign scoping is required, or what the response contains.

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

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

The description is a single short sentence with no filler and is easy to parse. It is appropriately concise, though the minor grammatical error and lack of detail slightly reduce clarity.

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

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

Given the absence of annotations and an output schema, the description is incomplete: it does not explain required parameter semantics, the meaning of 'details', or the shape of the returned object. An agent would have to infer most of the calling contract from the parameter names and tool name.

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

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

The schema has 0% description coverage and the description adds no meaning for the two required parameters, campaignId and id. The parameter names are somewhat self-explanatory, but the description does not clarify that id identifies the organization or how campaignId scopes the lookup.

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

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

The description states a clear verb and resource: 'Get details of a organization'. The singular 'a organization' helps distinguish it from list_organisations and from create/update/delete variants, though it does not explicitly mention that retrieval is by ID or campaign-scoped.

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

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

No guidance is given about when to use this tool versus alternatives like list_organisations or get_quest. The intended context is only implied by the 'get' verb and the resource name, with no explicit exclusions or 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?

There are no annotations, so the description carries the full burden of disclosing behavior. 'Get details' clearly indicates a read/retrieval operation rather than a mutation, but it does not mention error behavior, authentication needs, or what the returned details actually contain.

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

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

The description is a single efficient sentence with no redundant wording. It is front-loaded with the action and object, though the minimal length means some useful information is missing.

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 retrieval tool with two numeric required parameters and no output schema, the description is minimally usable. However, it omits the relationship between campaignId and id and provides no info on response shape or edge cases, leaving room for 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?

Schema description coverage is 0%, and the description adds no explanation of the two required parameters. The names id and campaignId are somewhat self-explanatory, but the description does not clarify how campaignId scopes or relates to the quest id.

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

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

The description uses a specific verb ('Get') and resource ('quest'), and the sibling list_quests makes it clear this is the singular retrieval tool. It is not tautological, though it lacks any scope or detail about what 'details' includes.

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

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

No guidance is given about when to use get_quest versus list_quests or other alternatives. The sibling tools imply a distinction, but the description itself provides no context, exclusions, or routing hints.

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

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

With no annotations, the description must disclose behavioral traits, but it only implies a read operation via 'Get'. It does not mention whether the returned data is a full object, how to handle missing races, or any auth/scoping constraints, so the agent is left without 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 single sentence is concise and front-loaded, but it is under-specified rather than economically informative. It lacks parameter details and context, so the brevity comes at the cost of usefulness.

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 there is no output schema and no annotations, the description is incomplete: it does not explain what details are returned, how the two required parameters work, or how this tool relates to the other get_*/list_* siblings.

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

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

Schema description coverage is 0% and the description mentions neither 'campaignId' nor 'id', so parameters are completely unexplained. An agent cannot infer that 'id' is the race ID and 'campaignId' scopes the request to a campaign.

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 action ('Get') and resource ('a race'), and the tool name confirms the entity type, distinguishing it from sibling get_* tools by resource. However, it does not specify that the race is scoped to a campaign or what 'details' includes, so it stops short of full clarity.

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

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

The description provides no guidance on when to use this tool instead of list_races, search, or other get_* tools. There are no exclusions or alternative routing, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Get details,' which implies a non-mutating read but does not disclose return format, pagination, error behavior, permissions, or 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 short and free of fluff, but it is also under-specified and largely restates the tool name. It is concise without being substantive, so it earns a middle score.

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 annotations, no output schema, and zero parameter documentation, a one-line generic description is not enough. The agent lacks critical information about required parameters, intended use, and expected behavior.

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

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

Schema description coverage is 0%, and the description adds no meaning for 'id' or 'campaignId.' An agent is left to guess which id this is and what role campaignId plays, so the description completely fails to compensate for the schema gap.

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 ('Get') and resource ('timeline'), so an agent can tell this is the individual-read counterpart to list_timelines. However, it does not explicitly differentiate itself from sibling get_* tools or mention that a campaignId is required, so it stops short of full clarity.

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

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

There is no guidance about when to use get_timeline versus list_timelines, search, or other get_* tools. The intended usage is only implied by the tool name and generic description, with no explicit context or exclusions.

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

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

With no annotations, the description carries the full burden. It does disclose a real behavioral trait — that oversized responses may not be returned whole, motivating the per_page hint — which is valuable context not in the schema. It says nothing about permissions, rate limits, or what the response envelope (pagination metadata) looks like.

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, front-loaded with purpose and then actionable parameter advice; every clause earns its place. The opening "List abilities" is slightly redundant against the tool name but serves as an anchor.

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 5-parameter list tool with no output schema and no annotations, the description is adequate but thin: it omits the mandatory campaignId scoping, pagination behavior, and the relationship between per_page and page. An agent could call it, but must open the schema to do so correctly.

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

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

Schema coverage is 80%, so the baseline is 3; per_page and entry_filter are already well documented in the schema, including defaults and the cross-collection filtering behavior. The description adds only a rationale (returning responses whole) rather than new semantics, and never mentions the required campaignId or the page 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?

"List abilities" states a specific verb and resource, making it distinguishable from get_ability, create_ability, and the other list_* siblings by name alone. However, it offers no explicit differentiation from the `search` sibling, which could plausibly return abilities too.

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 gives practical usage advice for two parameters (use per_page to keep responses whole, entry_filter to narrow by entry text), which implies the tool should be used with size control in mind. But it never states when to prefer this over search or get_ability, nor any prerequisites such as campaign membership.

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

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

With no annotations, the description carries the full burden, and it does disclose one non-obvious trait: per_page keeps responses "small enough to be returned whole," implying responses can otherwise be truncated. That is useful, but it says nothing about read-only nature, permissions, pagination defaults, or total-count behavior for a collection-listing tool.

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

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

Two sentences, no filler, and the resource is stated first followed by the two most operationally important parameters. The only weakness is that the parameter hints are compressed into one long sentence rather than structured.

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

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

For a 5-parameter list tool with no annotations and no output schema, the description covers response-size and filtering behavior but omits pagination mechanics, the required campaignId scope, and what a record contains. It is adequate to call correctly but leaves real gaps an agent would have to discover by reading the schema.

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

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

Schema coverage is 80%, so the schema already documents page, entries, per_page and entry_filter thoroughly. The description adds marginal value by framing per_page as a response-size safeguard rather than just a count, but it says nothing about campaignId (the only required param) or the page parameter, so it does not compensate for the remaining gap.

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+resource ("List calendars"), which unambiguously identifies it against the get/create/update/delete_calendar siblings. It does not distinguish itself from the many other list_* siblings or from search, but the resource is clear enough that an agent knows what it retrieves.

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 gives parameter-level guidance (use per_page to keep responses small, use entry_filter to narrow by entry state), which implies when the tool is useful. However, it never states when to prefer list_calendars over search or get_calendar, nor any prerequisite beyond the implicit campaign 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?

No annotations are provided, so the description carries the full burden for behavioral disclosure. 'List all campaigns' indicates a read operation but says nothing about return format, pagination, ordering, or whether any filtering occurs. The word 'all' adds some scope information, but the behavior is minimally disclosed.

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

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

Three words with no wasted content and the key action is front-loaded. For a zero-parameter, straightforward listing tool, this is appropriately concise rather than under-specified.

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, no-argument list operation, the description is nearly complete enough for an agent to invoke it correctly. Minor gaps remain around return shape and potential pagination, but the lack of parameters and the clear scope keep these from being significant.

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

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

The tool has zero parameters and the schema coverage is 100% vacuously. There is no parameter meaning for the description to add, so the baseline of 4 is appropriate. The description does not need to elaborate on parameters that do not exist.

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?

'List all campaigns' states a specific verb and resource, and the qualifier 'all' clarifies the scope. It is immediately distinguishable from the many sibling list_* tools by naming the exact resource. No ambiguity exists about what the tool does.

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

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

The description implies usage when the agent needs the full set of campaigns, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. Since there is no get_campaign sibling, the intended use is fairly obvious, but the guidance is still only implied.

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

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

No annotations are provided, so the description carries the full disclosure burden. It adds useful behavioral context about response size and whole-response return, but it does not state read-only semantics, permission requirements, pagination behavior, or return shape. For a read-oriented list tool this is adequate but incomplete.

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

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

The description is two short sentences, front-loads the core purpose, and uses the second sentence for practical parameter guidance. There is no filler, and every sentence contributes to correct invocation.

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

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

The tool has five parameters, no annotations, and no output schema, but only the per_page and entry_filter behavior are discussed in the description. The schema covers most other parameters, but the required campaignId has no description anywhere, and the return format is not explained. The definition is minimally sufficient but not complete.

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

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

Schema description coverage is 80%, so the schema already does most parameter documentation. The description highlights per_page and entry_filter, but mostly repeats what the schema says and adds little meaning beyond the existing descriptions. CampaignId, page, and entries remain undocumented in the 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 opens with a specific verb and resource: 'List characters.' That makes the core operation immediately clear and distinguishes it from get_character. It does not, however, mention campaign scoping or contrast with search/list alternatives, so it stops short of the strongest sibling differentiation.

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

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

The description gives concrete guidance for two parameters: use per_page to keep responses returnable whole, and entry_filter to narrow records by entry state. It does not say when to use this tool instead of get_character, search, or other list tools, so usage is implied rather than fully framed.

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

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

No annotations exist, so the description carries the full behavioral burden. It usefully hints that responses can be large and that per_page keeps them 'small enough to be returned whole', which implies truncation risk. It does not describe read-only nature, auth requirements, or the return shape beyond that hint.

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 tightly packed sentences with the resource statement front-loaded and the parameter guidance trailing; no filler. Slightly dense phrasing in the second sentence but still 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?

For a five-parameter list tool with no annotations and no output schema, the description covers response-size strategy but omits the required campaignId, pagination interplay, and any indication of what each record contains. Adequate but incomplete.

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

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

Schema coverage is high (80%) and the schema already explains per_page enforcement, defaults, and entry_filter's whole-collection semantics far more precisely than the description. The description's parameter sentences largely restate that, so baseline 3 applies.

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

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

States a specific verb+resource ('List creatures'), which is immediately distinguishable from get_creature/create_creature/update_creature. It does not, however, contrast itself with the more general 'search' sibling or clarify that it is the scoped collection listing for creatures.

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 gives operational advice for two optional parameters ('Use per_page to keep responses small', 'entry_filter to return only records whose entry is empty or filled'), but never says when to pick this over search or get_creature, nor states any prerequisites like campaignId being required.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful behavior: responses may not be returnable whole, motivating per_page. It omits other important traits — that campaignId is required for scoping, whether pagination metadata is returned, and what happens on out-of-range pages.

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, front-loaded with the operation and followed by the two highest-value parameter hints. No filler, no restatement of the title, nothing that could be cut without losing information.

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

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

For a five-parameter list tool with no annotations and no output schema, the description covers only the response-size and filtering story. An agent still lacks the campaign scoping requirement, the shape of the returned records, and pagination behavior — gaps the schema does not fill either.

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 80%, so the baseline is 3 and the schema already explains page, entries, per_page and entry_filter in detail. The description adds only the rationale for per_page (keeping responses whole) and a partial restatement of entry_filter; campaignId, the one required parameter, remains undocumented in both places.

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 and resource ("List events") that an agent can map directly to the operation, and pairs it with the two parameters that most affect the result. It does not, however, distinguish this from sibling readers such as get_event or search, nor does it say what an event record contains.

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 operational advice on when to set per_page and entry_filter, but it never addresses the larger routing question: when to call list_events versus get_event for a single record, search for cross-entity lookup, or the other list_* tools. Usage is implied by the parameter hints rather than stated as a selection rule.

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 bears the full disclosure burden, and it omits key traits: it never says the call is read-only, that campaignId is mandatory, whether responses are paginated (and how to detect the last page), or what the records contain. It hints that responses can be large and that per_page/entry_filter mitigate that, which is the only behavioral value added.

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, front-loaded with the operation and then the tuning knobs; no filler. Slight deduction because the second sentence packs two unrelated concerns (response size and filtering) without signaling the required campaignId.

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 five parameters with four richly described in the schema, no nested objects, and no output schema to explain, the description covers the operation and the two knobs an agent would actually reason about. The remaining gap (return shape) is minor for a simple list endpoint.

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 80%, so the schema already documents page, entries, per_page, and entry_filter in detail; the description only restates per_page and entry_filter at a higher level. It adds a small amount of intent (why to shrink responses) but no syntax, defaults, or limits beyond what the schema supplies, so baseline 3 applies.

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

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

The description opens with a specific verb+resource ("List families"), which cleanly separates it from get_family/create_family/update_family siblings. It stops short of naming those siblings or stating the campaign scope, but the operation itself is unambiguous.

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

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

The description explains how to use two optional parameters (per_page for smaller responses, entry_filter to narrow records), which implies usage context. However, it never states when to reach for this tool versus get_family or search, and gives no exclusions or prerequisites such as the required campaignId.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully hints at a response-size/truncation concern ("small enough to be returned whole"), which is real value beyond the schema, but it says nothing about permissions, ordering, or what a record contains.

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, purpose front-loaded, no filler. Every clause references a concrete parameter and its benefit.

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 five parameters, no annotations, and no output schema, the description should do more. It covers the pagination trade-off but omits the required campaignId, says nothing about ordering or what fields a record returns, and does not explain the interaction between entries=false and entry_filter.

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

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

Schema description coverage is 80%, so the baseline is 3. The description restates what per_page and entry_filter already document in the schema and adds no syntax or interaction detail; page, entries, and campaignId are not touched at all.

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 and resource ("List items") that matches the naming pattern of siblings like list_characters and list_locations, so the agent can infer the entity type. It does not explicitly distinguish this tool from search or get_item, but the list-vs-get split is conventional.

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

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

Gives practical guidance on how to use two parameters (per_page to keep responses whole, entry_filter to restrict by entry state), which is genuinely actionable. However, it never says when to choose this tool over siblings such as search or the per-entity list_* tools, leaving the routing decision implicit.

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

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

With no annotations at all, the description carries the full behavioral burden. It does disclose one genuinely useful trait beyond the schema — that per_page keeps responses "small enough to be returned whole," hinting at a truncation/size constraint. It says nothing about pagination totals, ordering, permissions, or what the returned records contain, so the disclosure is partial.

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 with the operation front-loaded and no filler. Minor redundancy in re-explaining entry_filter's enum values, which the schema already enumerates.

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?

Five parameters, no output schema, and no annotations place a substantial documentation burden on the description. It covers only two of the five parameters and never explains what a journal record contains or how the collection is ordered, so an agent must fall back on the schema and on inference from sibling tools.

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

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

Schema description coverage is 80%, so the baseline is 3. The description's remarks on per_page and entry_filter restate what the schema already says in more detail, adding no new semantics; campaignId, page, and entries are untouched in prose but well documented in 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 opening sentence names a specific verb and resource ("List journals"), so the agent knows exactly what operation this performs. It does not, however, distinguish itself from the many sibling list_* tools or from get_journal, so the reader must infer scope from the name alone.

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 guidance given ("use per_page to keep responses small", "use entry_filter...") is about parameter tuning, not about when to choose this tool over alternatives such as get_journal or search. There is no statement of when NOT to use it, no prerequisite call ordering (e.g., needing a campaignId from list_campaigns), and no exclusions.

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

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

With no annotations, the description carries the full burden. 'List' implies a safe read, and 'keep responses small enough to be returned whole' hints at a server-side response-size/truncation constraint that the schema does not state directly. However, it omits return shape, pagination metadata, and any permission or rate-limit 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 short sentences with zero filler, front-loading the core operation before the parameter tips. Every clause 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?

A paginated list tool with five parameters and no output schema. The schema is rich, but the description says nothing about the response shape (record list, total count, has_entry behavior) or the default page semantics, leaving the agent to rely on schema descriptions alone.

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

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

Schema description coverage is 80%, so the schema already documents page, entries, per_page, and entry_filter thoroughly. The description references per_page and entry_filter but adds no semantics beyond the schema (no format, default, or interaction details not already present). 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?

States a specific verb and resource ('List locations'), which contrasts adequately with the sibling get_location/create_location/update_location tools. It does not explicitly name an alternative list-style sibling or scope (e.g., per campaign), but the operation is unambiguous.

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

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

Gives parameter-level advice ('Use per_page...', 'entry_filter...') but no guidance on when to choose this tool over alternatives such as search or get_location, and no prerequisites or exclusions. The agent must infer tool selection entirely.

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

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

No annotations are provided, so the description carries the disclosure burden. It adds useful behavioral context about response size and collection-wide filtering, but it does not explicitly confirm read-only behavior, describe permissions/campaign scoping, or explain the returned record shape.

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 tightly written sentences with no waste. The core purpose is front-loaded, followed by targeted parameter 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?

The description covers the basic list operation and key pagination/filtering options, which is adequate for a simple collection tool. It omits the required campaign context and does not describe returned map records, leaving some gaps given that 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?

Schema description coverage is high at 80%, so the baseline is 3. The description mentions per_page and entry_filter but adds little beyond the schema, and it does not clarify page, entries, or the required campaignId 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 starts with a specific verb and resource: 'List maps.' This clearly distinguishes it from get_map, create_map, update_map, and delete_map. It does not explicitly distinguish list_maps from search or other list_* siblings, 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?

It gives practical parameter guidance, such as using per_page to keep responses small and entry_filter to narrow records. However, it does not say when to use list_maps instead of alternatives like search or get_map, leaving tool-selection guidance implicit.

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

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

No annotations are provided, so the description carries full disclosure duty. It does surface one genuinely useful behavioral trait: responses can apparently be truncated and per_page can prevent that. However it says nothing about result shape, ordering, or what a note record contains, and read-only nature is only implied by the verb "List".

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

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

Two sentences, no filler, and the actionable advice is front-loaded after the purpose statement. The opener is thinner than it needs to be for a five-parameter tool, but nothing is wasted.

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 no annotations, the description would need to carry result-shape and scope information; it only partly does. For a straightforward campaign-scoped list tool this is adequate to call correctly, but not enough for an agent to know what it will receive back.

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

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

Schema coverage is 80%, so the parameters are largely self-documenting and the baseline applies. The description restates per_page and entry_filter with a slightly new rationale (keeping responses small enough to be returned whole), but adds nothing on page, entries, or campaignId beyond what the schema already says.

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 opening sentence pairs a specific verb with a specific resource ("List notes"), which is unambiguous about the operation. It does not differentiate from the sibling retrieval tools (get_note, search), so an agent must infer when listing beats searching.

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 tuning advice for two parameters but never states when to use list_notes versus get_note or search, nor what preconditions exist (e.g., that campaignId is required). The one piece of conditional guidance — per_page for whole responses — is about invocation mechanics, not 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 discloses critical behavioral traits not obvious in the schema. It clarifies that entry_filter applies globally across the whole collection rather than just the current API page, which significantly impacts usage logic.

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 definition is highly efficient, using two concise sentences. Every word contributes to explaining the tool's operational constraints and value proposition.

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 list tool involving pagination and global filtering, this description is highly complete. It addresses the primary operational concerns an agent would face when trying to implement correct API usage.

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

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

Since the schema coverage is high (80%), the description focuses on providing semantic value for key parameters. It explains the operational purpose of 'per_page' (keeping responses small enough to be returned whole) and clarifies how 'entry_filter' works.

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 tool lists 'organisations' and serves its basic purpose well. However, given the large number of sibling listing tools, the description offers no unique details to distinguish this function from similar list functions.

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

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

The description provides clear operational guidance on how to handle the results. It advises the user to explicitly use per_page for pagination control and to leverage entry_filter for specific data requirements.

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 does add real behavioral context: responses may be too large to return whole, and entry_filter applies across the entire collection rather than one API page. It stops short of disclosing mutation risk (it is a read, but that is unstated), auth requirements, or default page size 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 tight sentences, front-loaded with the purpose and then the two most consequential parameters. Nothing is wasted, though the second sentence packs two distinct ideas into one clause.

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 five-parameter list tool with no annotations and no output schema, the description covers the response-size and filtering concerns but leaves the page parameter and the entries toggle entirely to the schema. That is adequate but not complete given the missing annotation and output-schema support.

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 80%, so the schema already explains page, entries, per_page, and entry_filter in detail. The description reinforces per_page and entry_filter but adds no syntax or format detail beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource ('List quests'), which cleanly separates it from the mutation siblings (create_quest, update_quest, delete_quest) and the single-record get_quest. It does not explicitly differentiate from search or from other list_* siblings, which keeps it 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?

It gives usage advice for two parameters (use per_page to keep responses small, entry_filter for empty/filled records), which implies when those knobs matter. However, it never says when to choose list_quests over search or get_quest, nor any preconditions beyond the required campaignId.

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?

Since no annotations are provided, the description must carry the full behavioral burden. It successfully explains the operational effect of parameters, but lacks crucial details regarding potential rate limiting, required scopes, or error handling, resulting in a minimum 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 extremely efficient, presenting the main purpose and critical parameter instructions in a single, focused sentence without unnecessary filler.

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

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

It covers the most operationally sensitive parameters—pagination and entry filtering—providing sufficient operational context for a listing tool, even without an output schema definition.

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 schema coverage is high, the description adds semantic value by explaining the 'why' behind critical parameters, such as why 'per_page' is used to ensure the response is 'returned whole,' which is operational context not present in 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 primary function is to 'List races.' While the tool name aids specificity, the description successfully identifies the resource being acted upon.

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 specific usage advice for two complex parameters, detailing when an agent should use 'per_page' (to manage response size) and 'entry_filter' (to narrow records based on content).

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