SpaceMolt

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

Beyond the readOnlyHint=false annotation, the description richly discloses behavioral consequences: mission removal, cargo retention or confiscation, and base-value charges for missing goods. It explains the exact economic impact (e.g., 'only delivery pays out'), providing the agent with complete behavioral 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 two sentences: a direct action statement followed by a detailed but necessary parenthetical explanation. Every clause earns its place, and the main verb+object is front-loaded, making the purpose immediately clear.

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

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

With no output schema, the description covers the essential behavioral outcomes (mission removal, cargo handling, monetary charges) thoroughly. However, it does not mention what the tool returns or handles error cases, which is a minor gap for a mutation tool. Overall, it is nearly complete for its complexity.

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

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

The input schema covers both parameters with descriptions (mission_id as UUID, session_id as session identifier), satisfying the baseline for 100% coverage. The description adds no additional parameter-specific meaning, as the schema already defines each field adequately.

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 'Abandon an active mission,' a specific verb+resource that clearly states the tool's function. It distinguishes itself from siblings like accept_mission and complete_mission by focusing on the act of abandoning an already-active mission, and the parenthetical further clarifies that it removes the mission from the active list.

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 rather than explicit: the description targets 'active mission' without naming when-not-to-use or alternative tools. It does not explicitly compare with decline_mission or complete_mission, leaving the agent to infer appropriate selection from the context.

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

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

With readOnlyHint=false, the agent already knows this is a mutating operation. The description adds important behavioral context beyond that: it requires being docked and enforces a five-active-mission limit. It also implies that accepting a mission consumes a slot. This is useful supplemental disclosure of preconditions and constraints.

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 a parenthetical containing only essential constraints. It is front-loaded with the core action and adds the most critical usage details without any fluff. Every word earns its place.

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

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

For a 3-parameter mutation tool with no output schema, the description provides the key prerequisites (docking, mission cap) and points to the companion tool for ID discovery. It does not explain the return value or failure behavior, but given the simplicity of the action and schema coverage of parameters, the description is adequately complete for an AI 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 100%, so each parameter has a description. The tool description adds context by referencing get_missions for mission IDs and mentioning that template_id takes priority (from schema). However, it doesn't clarify when to use mission_id vs template_id beyond what the schema already states. Since the schema carries the burden, a baseline 3 is appropriate.

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

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

The description clearly states the tool's action: 'Accept a mission from the mission board.' It uses a specific verb (accept) and resource (mission board), and distinguishes it from related tools like abandon_mission or decline_mission by focusing on the acceptance action. It also mentions the context of active missions, making the purpose unambiguous.

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

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

The description provides explicit usage constraints: 'You must be docked at the base offering the mission' and 'Maximum 5 active missions at once.' It also directs the user to get_missions for finding mission IDs. While it doesn't enumerate alternative tools to avoid, it clearly indicates when this tool is appropriate (docked, under the mission cap), which is strong 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?

The description adds useful behavioral context beyond the readOnly/idempotent annotations: insights depend on trading skill, include specific opportunity types (regional demand, price trends, arbitrage), and are limited to visited stations. No contradiction with annotations.

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

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

The description is only two sentences but contains redundancy ('Get actionable trading insights' vs 'Returns trading insights') and the inaccurate 'No parameters needed' claim. It could be more concise and accurate.

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

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

The description covers the tool's purpose and skill-based behavior, but with no output schema, it lacks details on the exact return format. The false parameter statement also creates a completeness gap, making this a minimally adequate description.

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

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

The description incorrectly states 'No parameters needed', directly contradicting the schema which requires session_id. This is actively misleading and could cause the agent to omit a required parameter, detracting from the schema's clear parameter documentation.

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

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

The description clearly states the tool's function: 'Get actionable trading insights at your current station' with specific scope ('stations you have visited') and skill-dependent opportunities. This distinguishes it from sibling tools like view_market by focusing on insight generation rather than raw market data.

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

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

The description provides clear context for when to use the tool: when the user wants trading insights based on their skill level, with higher skill revealing more opportunities. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

Annotations only state destructiveHint=true and readOnlyHint=false, but the description discloses far more: attacks create system-scale auto-resolving battles, repeat attacks do not fire extra volleys, pirate attacks summon nearby pirate combat hulls, empire NPC attacks apply criminal status, and station attacks start a siege with police response. This richly supplements the annotations without contradiction.

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

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

The opening sentence is clear and front-loaded, but the rest of the description is a single massive parenthetical block that is hard to scan. Dense and valuable, but poorly structured; it would benefit from bullet points or separation by target type.

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

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

With no output schema, the description explains exactly where to get battle results (get_battle_status, battle_damage/battle_update notifications, get_battle_summary) and covers all target types with distinct behaviors. Despite its length, it leaves little ambiguity for a complex combat 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?

Although the schema already describes both parameters with 100% coverage, the description adds essential semantics: target must be in the same system, and per-target-type consequences are explained (player re-targeting, pirate reputation penalty, wildlife hunt, station siege). This goes well beyond the schema's basic ID 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 opens with a specific verb and resource list ('Attack another player, pirate, empire NPC, creature, or station') and clearly distinguishes the tool from siblings by explicitly contrasting with the 'battle' command for tactical control and noting equivalence to 'hunt' for wildlife. This makes the tool's purpose unambiguous.

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

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

The description gives explicit when-to-use and when-not-to-use guidance: do not re-issue attack on a target already in battle, use 'battle' for tactical control, and use 'get_battle_status'/'get_battle_summary' for results. It also notes that attacking wildlife is equivalent to 'hunt', which helps select the correct alternative.

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

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

The description explicitly describes state-changing actions like 'advance', 'retreat', 'stance', 'target', and 'engage', which are not read-only. This directly contradicts the annotations' readOnlyHint: true and idempotentHint: true. The description fails to disclose any read-only or idempotency caveats, and the annotation flags are misleading, so the provided text offers no transparency and actually conflicts with the structured metadata.

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 fairly long but well-structured: it opens with a one-line summary, then breaks down each action with bullet-point-like formatting, and ends with examples. Every sentence adds value, and the 'help' pointer is a good fallback. It could be slightly more concise by merging the examples, but the structure aids readability.

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

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

Given the tool's complexity (5 params, 6 actions, no output schema), the description covers each action's required fields and effects fairly thoroughly. However, it does not explain return values or error conditions, and the contradictory annotation makes the overall behavior confusing. It is adequate but not fully complete for a tool of this complexity.

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

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

The schema already provides full descriptions for all parameters (100% coverage), but the description goes beyond the schema by explaining the actual action semantics (e.g., zone movement order, stance costs, target any combatant, side auto-assignment) and gives concrete examples. This adds meaningful context that helps the agent choose and fill in parameters correctly.

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

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

The description opens with 'Manage your battle — move, change stance, target enemies, or join a fight', which clearly states the tool's verb (manage) and resource (battle). It lists the six specific actions (advance, retreat, stance, target, engage, help) and thereby distinguishes it from sibling tools like 'attack' or 'get_battle_status', which serve different purposes.

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

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

The description provides explicit context for when to use each action (e.g., 'advance: Move one zone closer', 'engage: Join an existing battle') and points to 'action="help"' for full documentation. However, it does not explicitly compare to alternative tools (e.g., when to use 'attack' instead of 'battle' with action='target'), so it lacks a clear exclusionary guideline.

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

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

Annotations already declare readOnlyHint and idempotentHint, covering the safety profile. The description adds the base scoping behavior (current base vs. base_id) and filter options, but does not disclose other behavioral traits such as result format or empty-list behavior. This is adequate but not rich.

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 a parenthetical, making it compact. However, there is slight redundancy between 'at a base' and 'at the current base (or specify base_id)', which could be streamlined. Still, it is concise and front-loaded.

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

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

For a read-only listing tool with no output schema, the description covers the core functionality, base scope, and filters. It does not mention return fields or edge cases, but this is acceptable given the tool's simplicity and good annotation coverage. A minor gap is the lack of any statement about what the response contains.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description's mention of 'base_id', 'class_id', and 'max_price' mirrors the schema without adding new meaning, so it does not go beyond the baseline.

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 ('Browse') and resource ('ships listed for sale at a base'). The phrase 'player-listed ships' helps distinguish from NPC market listings, but no explicit alternative tools are mentioned, so it doesn't fully differentiate from 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?

The description implies usage when at a base and allows overriding with base_id, and mentions filters. However, it does not provide explicit when-to-use or when-not-to-use guidance or name alternatives like buy_listed_ship or view_market.

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

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

Beyond the readOnlyHint=false annotation, the description adds rich behavioral details: the station anchors at a new POI, your ship is automatically docked, the fee is taken from faction treasury then your wallet, and infrastructure requires maintenance from faction storage. It also discloses system limits and the need to use 'facility' faction_build afterward.

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

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

The description is a single dense paragraph, but every sentence contributes meaningful information about purpose, requirements, side effects, and follow-up. It is comprehensive without being overly verbose, though it could benefit from bullet points for readability.

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

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

For a complex action with many prerequisites and side effects, the description covers all necessary context: requirements, system limits, station behavior, and next steps. It also references 'get_base_cost' for preview and mentions the maintenance mechanic. No output schema is needed for an action.

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

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

Schema coverage is 100%, so all three parameters already have descriptions in the input schema. The description doesn't add new parameter-specific details beyond the schema, but it does provide contextual meaning for the 'name' parameter as the station name and 'public_access' as docking control, which are already covered. A baseline of 3 is appropriate.

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

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

The description clearly states 'Found a faction-owned station at your current point of interest in lawless space' with a specific verb and resource. It distinguishes from sibling tools like build_outpost by focusing on station construction and mentioning outposts separately.

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 lists explicit prerequisites (membership, ship holding Station Core, lawless system, POI without station, fee) and tells the user to use 'get_base_cost' to preview requirements. It also notes the one-station-per-system limit and that outposts are unlimited, implicitly guiding when to use this vs build_outpost, though it doesn't name the alternative directly.

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

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

Annotations only declare readOnlyHint=false, leaving the description to disclose critical behaviors. It enriches this with placement rules, docking effects, member-only access, built‑in storage/fuel bunker, no maintenance, and exclusions (stars/wormholes). This goes well beyond annotation coverage.

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

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

The description is lengthy but every sentence provides essential detail—requirements, exceptions, outcome, and alternatives. It is front-loaded with the core action and remains structured, though slightly verbose.

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

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

Given the tool's complexity and the absence of an output schema, the description thoroughly explains prerequisites, placement, resulting state, and features. It does not describe failure modes or explicit return values, but for a game action tool the outcome is sufficiently clear.

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

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

Schema coverage is 100% with both parameters already described (name, session_id). The description adds no extra meaning about these parameters, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Deploy') and resource ('lightweight, members-only faction outpost'), and clearly distinguishes from build_base by stating 'For a full station with services, use build_base instead.'

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

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

The tool explicitly lists detailed prerequisites (membership, permission, undocked ship, lawless system, POI without base, fee) and explicitly names an alternative ('build_base') when a full station is desired, making usage conditions clear.

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

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

The description discloses key behavioral traits: no fees for instant fills, delivery to cargo or storage when full, auto_list behavior with 1% listing fee (varying by station), and acceptance of item names. With only readOnlyHint:false in annotations, the description carries the burden and covers important side effects (fees, delivery). It does not mention return values or failure modes, but is otherwise transparent.

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

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

The description is a single, information-dense sentence that leads with the core purpose. It uses parentheticals to pack detail without rambling, though the delivery/fee clauses make it slightly dense. No wasted words, but it could be split for readability.

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

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

The description covers the essential context for a buy tool with 5 parameters and no output schema: market price, instant-fill fee waiver, delivery default, auto_list option with fee implications, and accepted item input forms. It omits specifics like response format or error conditions, but given the tool's straightforward buy action and the schema's parameter descriptions, it is reasonably complete.

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

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

Although schema covers 100% of parameters, the description adds meaning by clarifying that item_id accepts either an ID or a human-readable name (e.g., 'Iron Ore'), extending the schema's 'ID of the item' with examples. It also elaborates on auto_list fee variations ('1% default, higher at pirate strongholds') beyond the schema's flat '1% listing fee applies.' This adds value.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Buy items at market price from the station exchange.' It distinguishes from sibling buy tools (e.g., buy_ship_license, buy_listed_ship) by specifying 'items' and 'station exchange.' It also notes accepted input formats ('item_id or item name'), reinforcing its scope.

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

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

The description provides context on when to use the tool (buying at market price) and internal options (deliver_to, auto_list), but does not explicitly contrast with sibling tools like create_buy_order or cancel_order. It mentions when to use deliver_to=storage and auto_list=true, giving some situational guidance, but lacks explicit exclusions or alternative tool 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?

The description discloses that coverage equals fitted ship value, the premium is paid to the station insurer, and the rate is risk-based. These details go beyond the readOnlyHint=false annotation, which only implies mutation.

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

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

The description is compact, front-loaded with the action, and every sentence adds value—coverage formula, payment, and prerequisite. No redundant information.

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

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

For a tool with a single parameter and no output schema, the description covers the core behavior, the cost formula, and the prerequisite. It doesn't describe the return value or what happens if insurance already exists, but these are minor gaps.

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

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

Session_id is fully described in the schema, and the description doesn't add parameter-specific information. However, the mention of 'your current risk-based rate' provides context that the operation is tied to the ship associated with the session.

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 ('Purchase ship insurance') and specifies what that means: acquiring coverage equal to fitted ship value including hull and modules. It also differentiates from sibling tools like get_insurance_quote by highlighting the prerequisite.

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

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

It explicitly instructs to call get_insurance_quote first, providing clear context for when to use this tool. It does not mention exclusions like claiming insurance, but the prerequisite is a clear usage guideline.

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

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

Annotations only indicate readOnlyHint=false, but the description adds crucial side effects: 'Your current ship is stored at the base and the purchased ship becomes your active ship' and 'Credits go directly to the seller.' This goes beyond the annotation by explaining exactly what changes and how the transaction works, fully disclosing the mutation.

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 begins with 'Purchase a ship from the exchange' and then repeats nearly the same phrase in parentheses ('Buy a ship from the exchange'), making it redundant. While the content is short, the duplication is unnecessary and slightly bloats the description. A more concise version would omit the parenthetical repetition.

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

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

Given the tool's simplicity (only two parameters, no output schema), the description adequately covers the core behavior and consequences. It explains the precondition (docking), the post-purchase effect on the active ship, and the credit transfer. It lacks details on failure modes or response format, but these are not critical for such a straightforward transaction.

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

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

The schema provides complete descriptions for both parameters (listing_id and session_id) with 100% coverage. The description adds no additional parameter semantics beyond what the schema already states, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Purchase' and the specific resource 'a ship from the exchange', making it unmistakable what the tool does. It distinguishes itself from generic 'buy' and other ship-related tools like 'browse_ships' or 'place_ship_buy_order' by specifying the exchange context.

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

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

The description implies usage by stating the precondition 'Must be docked at the same base' and explains the outcome. However, it does not explicitly compare with alternatives such as 'buy' or 'commission_ship', nor does it state when not to use this tool. The guidance is present but indirect.

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

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

Beyond the minimal readOnlyHint=false annotation, the description discloses licensing costs (tiered T1-T5), royalty fees (10% of raw material value, with pirate hulls as a sink), permission requirements, and the full downstream workflow (faction-funded building, material sourcing, treasury payments, and disposition of the finished ship). This is thorough behavioral disclosure.

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

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

The description is a single dense paragraph packed with necessary details. It is efficient with no fluff, but the parenthetical-heavy structure makes it slightly harder to parse. Breaking it into separate sentences or bullets would improve readability without adding length.

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

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

Given the simple schema and no output schema, the description covers all essential aspects: purpose, prerequisites, costs, exclusions, and post-license process. It leaves no critical gaps for an agent to decide whether to use the tool or understand the consequences.

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

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

Schema coverage is 100% for both parameters, so the baseline is 3. The description adds value by clarifying that ship_class references a ship design from ship_catalog and providing an example ('solarian_frigate'), which helps the agent understand its format. It does not add much for session_id, but that is already self-explanatory.

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 'License a specific ship design so your faction can build it at its own stations,' which clearly identifies the action and resource. It distinguishes from sibling tools like buy_listed_ship and commission_ship by explicitly framing the license as a prerequisite for faction-based building, and even references commission_ship as a subsequent step.

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

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

Provides clear context: Empire and pirate hulls are exclusive to their territory, and this tool grants a per-design license. It notes exclusions (not starter or prestige hulls), requirements (ManageTreasury permission), and a follow-up action (commission_ship with fund_from_faction=true). It stops short of explicitly contrasting with alternatives in a 'when not to use' sense, but the use case is well defined.

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

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

The description discloses key behavioral outcomes: a 50% refund and return of supplied materials to station storage. This goes beyond the annotation readOnlyHint=false, which only indicates a mutation. It does not cover failure modes, but the core side effects are clearly stated.

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, information-dense sentence with a useful parenthetical. It front-loads the action and includes essential details without redundancy, making it easy for an agent 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 cancellation tool, the description covers what counts as cancellable, the refund, and material handling. No output schema exists, but the consequences are described. It could mention failure conditions, but the 'hasn't finished yet' constraint implies the scope.

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

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

The input schema already provides complete descriptions for both session_id and commission_id, covering 100% of parameters. The tool description adds no additional parameter-level detail, so the baseline of 3 applies.

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

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

The description clearly states the tool cancels a pending or in-progress ship commission, using a specific verb and resource. The parenthetical reinforces that it only applies to unfinished commissions, distinguishing it from related cancel tools like cancel_ship_buy_order or cancel_order.

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

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

The description provides clear context on when to use the tool (for pending/in-progress commissions) and includes consequences (50% refund, material return). It does not explicitly mention alternatives or when-not-to-use scenarios, but the 'ship commission' qualifier differentiates it from sibling cancel tools.

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

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

The description adds significant behavioral detail beyond the readOnlyHint=false annotation: it explains escrow return for both sell and buy orders, partial fill retention, and the bulk mode limit of 50 orders. This provides essential transparency for a state-changing 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?

Every sentence in the description adds value, covering normal cancel, special 'all' behavior, bulk mode, and partial fills. It is appropriately structured with parenthetical clarifications and stays reasonably concise for the complexity.

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

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

Given the tool's complexity (bulk mode, special order_id values, escrow handling), the description is complete and self-contained. No output schema exists, but the description covers the critical behavioral aspects, making it sufficient for an agent to use correctly.

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

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

The schema already covers all three parameters, but the description enriches the semantics by explaining special values ('all', '*') and the relationship between order_id and order_ids (top-level order_id is ignored when order_ids is provided). This goes beyond the schema descriptions.

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

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

The description clearly states the tool cancels an active order and explains the escrow handling for sell and buy orders. It distinguishes from sibling tools like cancel_ship_buy_order and cancel_ship_listing by specifying it handles station orders.

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 clear context on when to use the tool, including how to cancel all orders and bulk cancellation. It doesn't explicitly exclude alternatives, but the mention of order types and station scope implies the intended use case.

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 goes beyond the minimal readOnlyHint=false annotation by disclosing specific behavioral outcomes: full refund of escrow (price + sales tax), remote operation, and the showroom handling if the ship was already under construction. This is rich, useful context.

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

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

The description is a single, tightly packed sentence with a parenthetical detail section. Every clause adds value: the main action, the refund mechanics, the remote usability, and the edge case. No filler or redundancy.

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

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

For a simple mutation tool with two well-documented parameters, the description covers the main outcomes and an important edge case. With no output schema, it does not need to detail return values, and it is complete enough for an agent to invoke correctly.

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

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

Schema coverage is 100% with both parameters having descriptions (order_id and session_id). The main description adds no additional parameter-level semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb-resource pair ('Cancel one of your ship buy orders') and clearly states the associated refund behavior. It distinguishes itself from sibling tools like cancel_order, cancel_commission, and cancel_ship_listing by explicitly targeting ship buy orders.

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

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

The description provides clear context for when to use the tool ('Works from anywhere') and implicitly indicates it is the tool for canceling ship buy orders. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

Annotations only declare readOnlyHint=false (a write operation). The description adds meaningful behavioral details: cancellation is permitted for the seller or current owner, and the listing fee is not refunded. This goes beyond the annotation and sets expectations about 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 compact, front-loaded with the action, and uses a parenthetical to layer in extra conditions without wasting words. Every clause adds value.

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

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

For a simple cancellation operation with no output schema and two params, the description covers the core behavioral context: what it does, who can do it, and a key consequence (fee not refunded). It doesn't detail success/error responses, but those can be inferred from the operation and are not necessary for tool selection.

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

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

Schema coverage is 100% for both parameters (listing_id and session_id), each with a clear description. The tool description itself doesn't add extra semantics or restate param details, so it meets the baseline without exceeding it.

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

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

The description clearly states the action ('Remove your ship listing from the exchange') with a specific resource ('ship listing') and distinguishes it from sibling tools like 'cancel_ship_buy_order' by focusing on the listing itself. The parenthetical reinforces the action as 'Cancel a ship listing'.

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

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

The description provides clear context on who may cancel (seller or current owner) and when it applies (to cancel a ship listing). It doesn't explicitly mention alternatives, but the resource specificity makes the use case unambiguous. The non-refundable fee adds a cautionary note.

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 useful facts like 'Max 20 entries, max 100KB per entry. Oldest entries are removed when limit is reached.' However, the annotations declare readOnlyHint=true and idempotentHint=true, which directly contradict the described 'Add an entry' operation—a write that creates a new entry each time and is not idempotent. This is an annotation contradiction.

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

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

The description is awkwardly structured with nested parentheses and repeats 'personal journal'. The core information is present, but unnecessary repetition and punctuation hinder readability. It could be condensed into a cleaner single sentence.

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, but the annotation contradiction and inconsistent size limits create conflicting expectations. It does cover purpose and retention, but missing behavioral consistency and valid input ranges make it incomplete for reliable agent use.

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

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

Schema coverage is 100%, so baseline is 3. However, the description introduces a conflicting size limit: 'max 100KB per entry' while the schema's entry maxLength is 30000 bytes. This can mislead an agent about valid input. The description adds no useful parameter-level semantics beyond the schema.

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

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

The description clearly states the specific action 'Add an entry to your captain's log' and distinguishes it from sibling tools like captains_log_delete, captains_log_get, and captains_log_list by using the verb 'Add'. It also elaborates on the journal's purpose, making the tool's function unmistakable.

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

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

The description provides explicit context with 'Use this to record discoveries, plans, contacts, and thoughts,' and the overall purpose of a personal journal. It does not explicitly mention alternatives or when not to use, but the sibling set makes this the obvious write operation, so clear context is present.

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 claims a destructive operation ('Delete') while annotations declare readOnlyHint=true, which is a direct contradiction. Additionally, idempotentHint=true conflicts with the described re-indexing behavior, making repeated deletes non-idempotent. This is a serious transparency 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 a single sentence that efficiently packs the action, indexing rule, scope, re-indexing behavior, and error return. It is front-loaded with the verb and remains concise without unnecessary fluff.

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

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

For a simple delete tool with no output schema, the description covers the essential behavioral aspects: what is deleted, scope restriction, re-indexing, and error condition. However, the contradictory annotations introduce confusion that slightly reduces completeness in terms of safe usage expectations.

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

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

Schema description coverage is 100%, and the schema for both parameters (index and session_id) is self-explanatory. The description repeats the index semantics already present in the schema and adds the invalid_index return, but this is marginal beyond schema coverage. Baseline 3 is appropriate.

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

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

The description clearly states 'Delete a specific entry from your captain's log' with precise indexing semantics (0 newest, higher older). This distinguishes it from sibling tools like captains_log_add, get, and list, specifying the action and resource unambiguously.

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

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

The description provides clear context on when to use this tool: to delete one of your own log entries, with specifics about index behavior and re-indexing. It does not explicitly list alternatives or exclusion criteria, but the usage context is well implied by the scope constraint 'Only your own log entries can be deleted'.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safe read nature is covered. The description adds useful behavioral context by explaining the index ordering (0=newest, higher=older), which is essential for correct usage and not evident from annotations alone.

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

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

The description is a single, concise sentence that front-loads the core purpose and immediately clarifies the key indexing detail. There is no wasted text or redundancy.

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

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

For a simple read-only lookup with read-only annotations, a clear schema for both parameters, and no output schema needed, the description provides sufficient context. It explains the only non-obvious behavior (indexing) and leaves nothing critical uncovered.

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

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

Schema coverage is 100% and both parameters are described. The description repeats the index meaning already in the schema, adding no new semantic information beyond what the schema provides. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description clearly states the tool's function: retrieving a specific entry from the captain's log. It uses a specific verb ('get') and resource ('captain's log'), and the phrase 'specific entry' distinguishes it from sibling tools like captains_log_list, captains_log_add, and captains_log_delete.

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

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

The description implies the tool is for fetching one specific log entry rather than listing all entries, and explains the index semantics (0=newest). However, it does not explicitly name alternatives or state when not to use this tool, so it stops short of full exclusion guidance.

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

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

Annotations declare readOnly and idempotent, so the safety profile is known. The description adds ordering details (newest first, index 0) but fails to disclose that the tool actually returns one entry at a time with pagination metadata, contradicting the 'list all' claim. This is misleading.

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

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

The description is short and front-loaded, but the parenthetical adds confusion rather than clarity due to the contradictory claim about listing all vs single entry. It's concise but not effectively 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?

Missing explanation of pagination behavior, return metadata, and relationship to sibling tools like captains_log_get. The description fails to clarify what the agent should expect in terms of output, especially given the schema's paginated retrieval design.

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

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

Input schema covers 100% of parameters with descriptions. The description repeats the 'index 0 = newest' detail already present in the schema, adding no new semantic value. Baseline 3 applies due to high schema coverage.

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

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

The description claims to 'List all entries' but the input schema description says 'Get a captain's log entry by index (paginated, 1 entry at a time)', creating a fundamental contradiction about whether the tool returns all entries or a single paginated entry. This ambiguity undermines 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?

No guidance is provided on when to use this tool versus the sibling 'captains_log_get'. The description implies it's for listing, but the schema suggests it's for retrieving a specific entry, leaving the agent without clear 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?

Annotations already mark the tool read-only and idempotent. The description adds valuable context: facility lookups include the associated recipe, search also matches recipe items for facilities, and commissionable requires authentication and being docked at a shipyard with requirement checks. This far exceeds the baseline set by annotations.

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

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

The description is dense but comprehensive, fitting a complex 11-parameter tool into one paragraph. It front-loads the core purpose and then details nuances, but the block text could benefit from bullet points or clearer separation for scannability.

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 thoroughly covers filtering, pagination, authentication requirements, and special cases like facility recipes and commissionable checks. It does not explicitly state the response format, but given the read-only/idempotent annotations and the obvious nature of a lookup, this is a minor gap.

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

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

With 100% schema description coverage, the baseline is 3. The description goes beyond the schema by detailing facility categories, explaining how search matches facility recipe items, and clarifying commissionable's auth and docking prerequisites. However, parameters like tier, class, and empire are only indirectly referenced, so it doesn't fully maximize the opportunity.

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

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

The description clearly states the tool browses game reference data across five specific types with filtering and pagination. It uses a specific verb and resource, though it does not explicitly contrast itself with the sibling tool 'browse_ships' or other reference tools.

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

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

The description implies usage for querying reference data but provides no explicit guidance on when to use this tool versus alternatives like 'browse_ships' or 'facility'. No exclusions or alternative recommendations 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?

The description directly contradicts the annotations: it describes a write operation ('Send a chat message') while annotations declare readOnlyHint=true and idempotentHint=true. This is a severe transparency failure; the model may incorrectly assume no 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, front-loaded sentence that efficiently conveys the core action and the main parameter nuance. No filler or redundant content.

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

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

For a chat send tool, the description covers channels and the private target requirement. Absence of output schema makes return value explanation unnecessary. The main gap is the annotation contradiction, which is accounted for in behavioral transparency.

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

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

The input schema has 100% coverage, but the description adds meaningful semantics: it explains each channel's meaning (current system, POI, faction, private) and clarifies that target_id accepts a player ID or username. This goes beyond the schema's basic field descriptions.

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

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

The description clearly states the tool's action ('Send a chat message') and specifies the resource (chat channels). It enumerates the four channel types with brief clarifications, distinguishing it from read-only sibling tools like get_chat_history.

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

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

The description provides clear context on when to use each channel and notes that private channel requires a target_id. It doesn't explicitly mention alternatives, but the channel breakdown implicitly guides the agent to choose appropriate usage.

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

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

Beyond the readOnlyHint:false annotation, the description discloses extensive behavioral details: fees held in escrow and only retained on grant, auto-approve vs petition queue behavior, exclusive empires automatically renouncing other citizenships, and the permanence of renunciation. This far exceeds what the minimal annotation provides.

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

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

The description is long but well-structured with clear sections (Concepts, Actions, Exclusive empires, Errors). The opening sentence provides a compact summary, and each section earns its place, making the length appropriate for the tool's complexity.

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

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

The tool is complex (four actions, multiple edge cases) and has no output schema, yet the description explains what list returns (origin, citizenships, per-empire summaries), what each mutation accomplishes, and potential errors. It is fully self-contained and leaves no significant gaps.

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

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

Although the input schema already documents all parameters with 100% coverage, the description adds substantial meaning: it explains the origin vs citizenship distinction, defines the numeric gates (min_balance, fee, min_reputation), and details how exclusive empires affect actions. This goes well beyond the schema's 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 opens with 'View and manage your empire citizenships (list, apply, renounce, withdraw)', clearly identifying the tool's scope and all actions. It distinguishes itself from sibling tools by covering all citizenship management operations in one place, making the purpose unmistakable.

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

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

The description provides explicit guidance on when to use each action, such as requiring empire_id for mutations and noting list is the default. It also recommends checking get_tax_estimate before assuming tax implications, offering an explicit alternative. Additionally, it warns that renouncing is permanent, informing when to avoid the action.

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 directly contradicts the annotations: it describes a state-changing operation (linking a player) while readOnlyHint is true. The claim that each player can only be claimed once also suggests non-idempotency, conflicting with idempotentHint. This is a serious inconsistency that misleads the agent about the tool's 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 somewhat redundant, repeating 'Link your player to your website account' in both the main sentence and the parenthetical. The structure is awkward and could be more concise. However, it is not overly long and includes key details, so it is at an acceptable level of conciseness.

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

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

For a simple two-parameter tool with no output schema, the description covers the essential usage context: purpose, prerequisite, and a uniqueness constraint. It explains why to use the tool (dashboard visibility) and where to obtain the registration code. However, the annotation contradiction introduces confusion that prevents a perfect score.

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

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

The input schema already provides clear descriptions for both parameters (session_id and registration_code) with 100% coverage. The description adds the URL source for the registration code and the purpose of the link, but these are also present in the schema. It does not add meaningful new semantics beyond the schema.

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

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

The description clearly states what the tool does: it links the player to a website account using a registration code. The verb 'link' is specific, the resource (player to website account) is clear, and the method (registration code) is explicit. This distinguishes it from sibling tools like login_link, which involve a different linking mechanism.

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

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

The description provides clear context on when to use the tool: to link a player to a website account for dashboard visibility. It also informs the user of the prerequisite (obtain a registration code from the dashboard) and the uniqueness constraint (each player can only be claimed once). It does not explicitly exclude alternatives or name sibling tools, but the context is sufficient.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, which the description aligns with by using 'view'. The description adds minimal context by specifying 'active' policies, but does not disclose return format, session requirements beyond the schema, or how this differs from similar tools.

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

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

The description is a single, front-loaded sentence that is direct and free of filler. It efficiently conveys the core function with zero wasted words.

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

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

For a simple read-only tool with one well-documented parameter and strong annotations, the description is mostly sufficient. However, it fails to clarify the relationship to the tool name 'claim_insurance' and how it differs from 'view_insurance', leaving a gap in contextual completeness.

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

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

Schema coverage is 100% with the only parameter 'session_id' already described clearly. The description adds no additional meaning about the parameter itself, but this is acceptable since the schema fully documents it. No extra param context is needed beyond what is provided.

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

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

The description clearly states the tool's function with a specific verb ('view') and resource ('active insurance policies'). However, it does not differentiate from the sibling tool 'view_insurance' and the tool name 'claim_insurance' suggests an active claim action, creating a potential mismatch.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'view_insurance' or 'buy_insurance'. There are no exclusions, prerequisites, or context about when this tool is preferred.

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?

Goes well beyond the minimal annotation (readOnlyHint: false) by disclosing the mechanics: cloak strength calculation, skill scaling, contest against scanners, and the fact that the reported strength is the exact value to beat. This is rich behavioral detail.

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 bit long but well-structured: it starts with the action, then prerequisites, effect, and detailed mechanics. Every sentence carries useful information, but a more concise phrasing could be possible.

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 toggle action with no output schema, the description covers prerequisites, the mechanic thoroughly, and the exact meaning of the reported value. It is complete enough for an agent to decide when and how to use the tool.

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

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

The input schema already provides 100% coverage with descriptions for enable, quantity, and session_id. The description does not add extra parameter-level details, so baseline 3 is appropriate.

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

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

The description clearly states 'Toggle cloaking device' — a specific verb and resource. It differentiates from sibling tools like scan by explaining the hiding effect and the mechanics of cloak strength versus scanner power.

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

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

Provides a clear prerequisite: requires a cloaking device module or integrated cloak. It also explains the effect (hidden from players) which implies when to use. However, it does not explicitly name alternatives or when-not-to-use conditions, so it misses the top score.

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?

Although annotations already declare readOnlyHint=true and idempotentHint=true, the description adds valuable behavioral context: it clarifies that the tool returns pricing for both payment modes, lists potential blockers, and explicitly states it does not place an order. This goes beyond what annotations alone convey.

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

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

The description is two sentences long, with the first sentence stating the primary purpose and the second adding key details about output and side effects. Every word earns its place; no fluff or repetition.

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

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

The description is appropriately complete for a simple read-only quote tool with no output schema. It explains what the returned details include (pricing modes and blockers) and clarifies non-action. It does not mention specific error conditions or prerequisites, but given the tool's simplicity and annotations, this is largely sufficient.

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

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

Schema coverage is 100% for the two parameters (session_id and ship_class), and the description does not add any additional meaning beyond what the schema already provides. Baseline of 3 is appropriate since the schema fully documents the 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 clearly states the tool's purpose with a specific verb ('Get a cost estimate') and resource ('commissioning a ship'). It distinguishes itself from the sibling tool 'commission_ship' by explicitly noting 'Does not place an order,' which resolves potential ambiguity.

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

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

The description provides clear context for when to use this tool (to preview cost estimates and blockers before commissioning). It implicitly differentiates from actual commissioning by noting it does not place an order, but does not explicitly name alternatives or state exclusions, falling just short of a 5.

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

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

The description richly discloses behavioral consequences: the refundable yard fee, faction funding requiring ManageTreasury, material sourcing from faction storage, the delivery/resale of the hull, build time dependence, and the asynchronous ship_commission_complete event. Annotations only state readOnlyHint=false, which aligns with the mutating nature of commissioning; there is no contradiction. The description significantly exceeds annotation coverage.

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

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

The description is long but each sentence earns its place, covering payment modes, faction exception, delivery, quote reference, build time, and completion event. It is front-loaded with the core purpose. While not 'concise' in word count, it is appropriately sized for the tool's complexity. The use of parentheses and semicolons organizes related details, but a slight tightening could improve readability.

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

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

For a tool with 4 parameters, no output schema, and no destructiveHint annotation, the description is exceptionally complete. It explains not only the mechanics (payment modes, faction funding, materials, yard fee) but also the asynchronous completion event and the reason to prefer it over list_ships diffing. The immediate return value is not specified, but the omission is minor given the depth of operational detail provided.

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

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

The schema already covers all 4 parameters at 100% coverage, so the baseline is 3. The description adds meaning beyond the schema by explaining the interplay between fund_from_faction and provide_materials with station types, the default credits-only mode, and the ManageTreasury requirement. It also clarifies ship_class usage indirectly via ship_catalog. This is meaningful added value, but not a full 5 since the schema descriptions are already informative.

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: 'Commission a ship to be built at this shipyard (Place a build order at the current base's shipyard.' It clearly identifies the action and scope, and distinguishes itself from sibling tools like commission_quote, supply_commission, and cancel_commission by noting 'Use commission_quote to see requirements.' This is more than just a restatement of the 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 explicit guidance on when to use each payment mode: credits-only vs provide_materials at empire/NPC shipyards, and fund_from_faction at your own faction's station. It also states that credits-only/provide_materials are rejected at faction stations, and recommends using commission_quote for requirements. This goes beyond vague hints and directly informs tool selection and configuration.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds substantial behavioral detail: the progress lifecycle (pending → building), delivery of the finished ship to fleet docked at the build station, and the crucial caveat that the commission disappears on completion and only the push notification carries both IDs. This is exactly the kind of context that helps an agent handle edge cases.

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

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

The description is a single dense sentence with multiple clauses, but every piece of information serves a purpose: scope definition, filtering option, lifecycle, delivery, and completion behavior. It is slightly longer than strictly necessary but not wasteful.

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

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

With no output schema, the description carries the burden of explaining what the tool returns and how to interpret it. It covers what appears in the list, the progress states, post-delivery behavior, and the need to rely on the push notification for both IDs. It also directs to switch_ship as the next step, making the tool's role in the workflow clear.

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

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

Schema covers 100% of parameters with descriptions, so baseline is 3. The description enriches base_id by tying it to the build station/delivery context, and clarifies that base_id is an optional filter, which adds semantic meaning beyond the schema's bare 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+resource: 'Check the status of your ship commissions'. This clearly distinguishes it from sibling tools like commission_ship, commission_quote, cancel_commission, and supply_commission, which involve creating, quoting, or canceling commissions rather than viewing active ones.

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

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

It states that it shows all active commissions and optionally filters by base_id, giving clear context for when to use it. It does not explicitly name alternatives or exclusion criteria, but the focused domain language (ship commissions status) implicitly differentiates it from related tools like get_active_missions.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds that it returns all completed missions with specific fields, which is useful behavioral context. It does not mention pagination or ordering, but given the strong annotations, this is sufficient.

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

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

The description is a single sentence with a parenthetical clarifying the output fields. Every word serves a purpose, and the main action is front-loaded.

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

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

For a simple list tool with one well-documented parameter, strong read-only annotations, and an output field enumeration, the description is complete. No output schema exists, but the parenthetical fully covers return values.

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

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

The input schema already documents session_id clearly ('Your session ID from login/register') with 100% coverage. The description does not add further parameter-specific detail, so it meets the baseline of 3.

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

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

The description uses the specific verb 'List' with the resource 'completed missions', clearly distinguishing it from active mission tools by the word 'completed'. It also enumerates the fields returned (template ID, title, type, difficulty, completion time, giver), making the purpose unambiguous.

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

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

The description specifies the scope ('missions you have completed') but does not explicitly contrast with sibling tools like get_active_missions or get_missions. Usage guidance is implied rather than 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?

Beyond the readOnlyHint=false annotation, the description discloses important behavioral details: prerequisites, docking requirement for delivery missions, partial contribution handling for community missions, and types of rewards (credits, items, skill XP). It gives the agent a clear picture of side effects and constraints.

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 a parenthetical that bundles essential details without unnecessary words. The core action is front-loaded, and every clause adds useful context. It is concise yet complete.

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 low complexity (2 simple parameters, no output schema), the description covers all necessary context: prerequisites, mission-type-specific behaviors, and rewards. It does not leave obvious gaps about when or how to use the tool.

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

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

The input schema already provides descriptions for both parameters (mission_id and session_id) with 100% coverage. The description does not add additional meaning about the parameters themselves, so it stays at the baseline of 3.

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

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

The description starts with a clear verb and object: "Complete a mission and claim rewards," which directly states the tool's purpose. It also differentiates from sibling tools like abandon_mission and accept_mission by specifying the completion and reward-claiming action. The scope (mission objectives fulfilled) is explicit.

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

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

The description provides explicit conditions for use: "Mission objectives must be fulfilled," and gives specific guidance for delivery and community missions, including that community missions can be called repeatedly. This tells the agent when and how to invoke the tool, even without naming 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 only readOnlyHint=false in annotations, the description carries the full burden and exceeds it: explains asynchronous job queueing, escrow from station storage, output delivery, hand-crafting pausing when undocked, dry_run non-committal behavior, bulk partial success, cancellation refunds, retarget permission restrictions, and package exact-match constraints. It also mentions the crafting_update notification, which is valuable operational context.

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

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

The description is quite long and repeats information already in the schema (e.g., package_ids exact match, quantity rounding). It does use ALL-CAPS section markers for BULK, QUEUE & CANCEL, RETARGET, etc., but the dense prose could be tighter. The first sentence is front-loaded with the core purpose, though overall it is not concise.

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

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

For a tool with 19 parameters and no output schema, the description is exhaustively complete: it covers queue, cancel, retarget, bulk, all four presets, package input/output, package recipes, dry_run, prerequisites, permissions, and failure conditions. An agent would have enough context to use the tool correctly across all modes without needing external information.

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

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

Schema description coverage is 100% with per-parameter docs, so the baseline is 3. The description adds context beyond the schema: how quantity rounds up to production runs, how source/target default to deliver_to, how action/job_id/job_ids interact, and how preset values affect routing decisions. This clarifies multi-parameter semantics and edge cases beyond the structured 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 opening sentence states the specific action ('Queue a crafting job') and resource, with clear scope: auto-routing to facilities or hand-crafting at the Station Workshop. It distinguishes the tool from siblings by explicitly mentioning 'recycle' as the reverse operation and 'catalog' for finding recipes, which differentiates it from nearby tools.

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

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

The description gives explicit when-to-use guidance: 'Use ''recycle'' to reverse a recipe', 'add dry_run=true to get a quote', 'call craft with no recipe (action=queue) to list your queued jobs', and detailed preset trade-offs. It also states prerequisites ('Must be docked', 'deposit your inputs to storage first') and clarifies notification behavior to avoid duplicate issuing.

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

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

Beyond the readOnlyHint=false annotation, the description reveals substantial behavioral details: listing fees on order book portions, instant fills incurring no fee, delivery defaulting to cargo, consolidation of matching orders, and bulk mode limits. This significantly enriches the agent's understanding of side effects and edge cases.

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

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

The description is a single dense paragraph with useful information. It front-loads the main purpose, then covers fees, delivery, item naming, bulk mode, and consolidation. It is concise but slightly long; breaking into bullets could improve scannability without adding length. Still, every sentence provides value.

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

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

Given the complexity (bulk mode, fees, consolidation, delivery options) and no output schema, the description covers most important behavior. It explains the consolidation response detail but does not describe the general return payload or error conditions. It is reasonably complete for a create-order operation with rich annotations.

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

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

The input schema already covers all 6 parameters with descriptions (100% coverage), so baseline is 3. The description adds meaning by clarifying that item_id accepts item names (e.g., 'Iron Ore'), explaining bulk mode semantics, and specifying default deliver_to behavior. This exceeds schema information but does not fully reinvent parameter documentation.

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

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

The description clearly states 'Place a buy offer on the station exchange', identifying the specific verb and resource. It distinguishes from related tools like 'create_sell_order' and 'buy' by focusing on exchange buy offers, and adds unique details like listing fees and order consolidation.

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

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

The description provides clear context for using the tool, including fee structure, delivery options, and bulk mode. It implies when to use it (placing buy orders on the station exchange) but does not explicitly contrast with direct purchase tools like 'buy' or mention when not to use it. This is clear context without explicit exclusions.

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

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

Beyond the readOnlyHint false annotation, the description discloses that both name and tag must be unique and that tag must be exactly 4 characters. This adds important context for the agent about validation requirements, though it does not mention 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 a single, front-loaded sentence that states the purpose first, then adds validation rules in a parenthetical. Every word earns its place, with no redundancy or fluff.

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 creation tool with three parameters and no output schema, the description covers the essential purpose and constraints. It does not detail return values or error conditions, but these are not critical for basic 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?

The schema already documents all three parameters and their basic constraints. The description adds the stricter rule that tag must be exactly 4 characters (schema allows 2-4) and that tag must also be unique, providing useful extra semantics despite the minor inconsistency with the schema's minLength.

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 'Create' with the resource 'faction', clearly stating the operation. It also includes key constraints (tag length and uniqueness) that distinguish this tool from the many other faction-related tools in the sibling list.

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

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

The description implies usage for creating a new faction, but does not explicitly contrast with alternatives like join_faction or mention prerequisites such as not already being in a faction. No when-not-to-use guidance is provided.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, but the description describes a mutating creation operation. This is a direct contradiction. Idempotency is also questionable since each call creates a new note. Description cannot recover from this inconsistency.

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

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

The description is compact and front-loaded with the core purpose. The parenthetical packs constraints and requirements efficiently, though it becomes slightly dense with multiple clauses. Still effective and not bloated.

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

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

Covers purpose, constraints, and prerequisites, which is adequate for a simple creation tool. However, it does not mention return values or how to access the created note, and the annotation contradiction undermines overall completeness. Minimum viable with clear gaps.

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

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

Schema coverage is 100% with all three parameters fully described. The description repeats max lengths already present in the schema and adds no additional param-specific semantics. Baseline of 3 is appropriate.

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

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

Description starts with a specific verb+resource: 'Create a new note document' and further clarifies 'Creates a tradeable text document.' This clearly distinguishes it from siblings like read_note, delete_note, and get_notes by emphasizing creation of a new, tradeable note.

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

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

Provides clear context with prerequisites 'Requires docking and 1 cargo space,' and implies a creation scenario. Does not explicitly name alternatives or exclusions, but the context is sufficient for an agent to know when to use this tool.

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

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

The description goes well beyond the readOnlyHint annotation (which is false) by disclosing key behaviors: listing fees, escrow priority from cargo then station storage, consolidation of duplicate orders, and bulk mode limits. It also mentions the response includes consolidated=true and existing order_id, giving agents insight into 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 long but front-loaded with the primary purpose. It packs substantial information (fees, escrow, consolidation, bulk mode) into a single paragraph, though the parenthetical nesting makes it slightly harder to parse. Every sentence contributes useful information.

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

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

Given the tool's complexity (bulk mode, fees, consolidation, no output schema), the description covers essential operational details: fees, escrow order, duplicate handling, and bulk mode limits. It doesn't describe error conditions or full response format, but the core behavior is well covered.

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

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

The schema already covers 100% of parameter definitions, but the description adds extra semantics: it clarifies that item_id accepts either an item ID or a human-readable name like 'Iron Ore'. It also explains consolidation behavior relevant to how parameters are used, though the bulk-mode schema already covers the ignoring of top-level fields.

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

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

The description clearly states the tool's function: listing items for sale on the station exchange. It distinguishes itself from related tools like create_buy_order and sell by describing sell-order-specific behaviors (fees, consolidation). The verb 'List items for sale' is specific and unambiguous.

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

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

The description provides rich context about when this tool is appropriate: for station exchange listings, with details on fees and instant fills. It does not explicitly mention alternatives or exclusions, but the context makes it clear this is for sell orders on the exchange.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds key behavioral context: it returns the NPC's decline dialog, has no destructive effect, and requires docking. This goes beyond the safety annotations by clarifying the exact outcome and prerequisite, earning a strong 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 two sentences, front-loads the core action, and every clause provides useful information (return dialog, availability persistence, docking requirement). No wasted words.

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

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

For a simple state-changing-in-appearance but actually read-only tool, the description covers the return value (decline dialog), side effect (mission remains available), and prerequisite (docked at base). With strong annotations and full schema coverage, this is fully complete for an agent to select and invoke correctly.

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

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

The schema covers 100% of parameters with clear descriptions, so the description need not explain them. The description adds no extra parameter meaning, but it doesn't need to—baseline 3 is appropriate when the schema carries the burden.

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

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

The description clearly states the verb ('Decline') and resource ('a mission'), and distinguishes it from siblings like accept_mission and abandon_mission by noting that the mission remains available for later acceptance. This makes the tool's unique purpose immediately obvious.

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

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

The description provides a specific usage condition ('Must be docked at a base where the mission is available') and implies the tool is for declining rather than abandoning by stating the mission remains available. However, it does not explicitly contrast with abandon_mission or name alternative tools, so it misses the top score.

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

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

The description discloses destructive behavior (permanent deletion, frees cargo slot, cannot be undone) but the annotations declare readOnlyHint=true and idempotentHint=true, directly contradicting the described behavior. This is a serious annotation contradiction.

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

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

The description is a single concise sentence with a parenthetical, but it redundantly repeats permanence ('permanently delete' vs 'permanently destroys'). It remains short and front-loaded with the key action.

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

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

For a simple two-parameter delete operation, the description covers ownership, permanence, cargo slot effect, and docking requirement. This is relatively complete for invocation, though the annotation contradiction adds confusion.

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

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

The input schema provides 100% coverage with clear descriptions for both session_id and note_id. The description adds ownership context but does not significantly enhance parameter understanding beyond the schema.

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

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

The description clearly states 'Permanently delete a note document you own' with a specific verb and resource, and emphasizes permanence and destruction, distinguishing it from note creation/reading 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?

It specifies that you must own the note and that docking is required, providing clear context for when to use the tool. It doesn't explicitly name alternatives, but the constraints are sufficient for basic 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?

Beyond the annotation readOnlyHint:false indicating mutation, the description discloses that deploying consumes bandwidth and that the 'all' option skips drones exceeding remaining bandwidth. It also states the prerequisite that the drone must be loaded, which is important operational context not present in annotations.

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

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

The description is a single, well-structured sentence with a parenthetical that packs essential info without redundancy. Every clause serves a purpose: the action, prerequisite, resource implications, and follow-up action, all in ~40 words.

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

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

Given the tool's complexity (prerequisite, bandwidth cost, bulk deployment), the description covers all necessary context: what happens, the loading requirement, the bandwidth consumption, and the subsequent action. With no output schema, it does not need to explain return values, and it leaves no critical gaps.

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

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

Although the schema covers all parameters at 100%, the description adds meaning by explaining the two operational modes (specific drone via drone_id vs. all drones via all:true) and clarifies that drone_id references the listing from get_drones. It reinforces the 'skipped' behavior for all, which is essential for understanding parameter semantics.

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

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

The description clearly states the action ('Deploy a drone from your bay into space') with a specific verb and resource. It also distinguishes from related tools by mentioning prerequisites (drone must be loaded) and follow-up actions (upload_drone_script), grounding the purpose in the overall workflow.

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

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

The description explicitly says when to use this tool ('Drone must be loaded in your bay'), what to use before (get_drones), and after (upload_drone_script). It also explains the optional 'all' behavior and its constraint, providing clear context for choosing between targeting a specific drone or deploying all.

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

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

The description discloses the default direction, the one-call cross-storage capability, and the docking requirement. Since annotations only set readOnlyHint=false, the description carries the transparency load, but it omits potential transaction fees or permission requirements (though schema hints manage_treasury).

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

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

Two sentences front-load the core purpose, though the parenthetical is slightly dense. No wasted words.

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

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

For a 5-param tool with no output schema, it covers the core behavior, defaults, and prerequisite. It could mention return/errors, but overall sufficient.

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

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

Schema covers all parameters with descriptions. The description adds value by illustrating the source/target combination with an example and the 'no cargo loop' shortcut.

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 'Move items from cargo (or directly from personal/faction storage) into a storage destination' with explicit defaults. However, it doesn't position itself against the sibling tool faction_deposit_items, which overlaps in functionality, so it's not fully distinguished.

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

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

It specifies the prerequisite 'Must be docked at a base with storage service' and explains how to set source/target for direct transfers. It does not explicitly name alternatives like withdraw_items or faction_deposit_items, so guidance is contextual rather than comparative.

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 only readOnlyHint=false, the description carries full responsibility and does so excellently. It discloses that the entire outpost (base, POI, lockbox, fuel bunker) is packed into a kit, the founding fee is not refunded, and you are set adrift afterward. It also notes the refusal condition to prevent loss, offering complete behavioral 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 longer but each sentence provides essential operational detail (contents, prerequisites, refund, cargo space, outcome). It is front-loaded with the core action and structured logically, though a slight reduction in parenthetical phrasing could improve conciseness.

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

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

For a complex mutation tool with a single parameter and no output schema, the description covers all necessary context: permissions, prerequisites, result (kit in cargo), refund policy, and final state (adrift). No important operational detail is missing.

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

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

The schema has 100% coverage for the only parameter (session_id), so the description adds no additional semantic value. Baseline of 3 is appropriate since the parameter is fully documented by 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 a specific action and resource: 'Dismantle a faction outpost you're docked at', and distinguishes it from related tools by noting it is for faction outposts (not full stations) and produces an Outpost Kit. This is unambiguous and well-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?

Provides explicit usage conditions: must be docked at your faction's outpost (not a full station), requires ManageBases permission, storage must be emptied first, and free cargo space is needed. It also explains when the action is refused, effectively guiding when to use it.

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

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

Beyond the readOnlyHint=false annotation, the description discloses significant behavioral details: auto-assignment of investigation missions, expiration after 3 hours, cooldown, and docking restriction. It also explains the meaning of each distress type, providing rich context about 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, information-dense sentence with a parenthetical block. Every clause adds value (types, constraints, expiration, cooldown), but there is slight redundancy in 'Broadcast...' followed by '(Broadcasts...' which prevents a perfect score. Still, it is well-structured and front-loaded.

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

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

For a tool with no output schema, the description covers the essential aspects: purpose, types, constraints, and side effects. It lacks details on potential costs or response format, but given the simplicity of a distress signal action, it is sufficiently complete for an agent to invoke it correctly.

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

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

Schema coverage is 100%, with both session_id and distress_type fully described. The description repeats the type explanations but does not add new syntax or format details. Baseline of 3 is appropriate since the schema carries the parameter documentation burden.

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 ('Broadcast a distress signal') and clearly states its function: to auto-assign investigation missions to nearby players in the same system. It also distinguishes itself by detailing emergency types (fuel, repair, combat), making its purpose unique among siblings.

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

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

The description explicitly defines when to use the tool via the three emergency types and provides clear constraints: cannot be used while docked, only one active signal at a time, and a 1-hour cooldown. This gives the agent explicit when/when-not guidance, even without naming an alternative tool.

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

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

The annotation only indicates readOnlyHint=false, so the description must carry the burden of behavioral disclosure. It adds no context about movement, cooldowns, requirements, or effects beyond 'dock'.

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, focused sentence with no wasted words, front-loaded with the action and target.

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 (one parameter, no output schema), but the description lacks any behavioral context or usage nuance. It is minimally viable yet incomplete for an agent needing to know side effects or failure conditions.

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

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

The input schema fully documents the single parameter 'session_id' with a clear description, so the tool description need not add more. It does not, but 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 "Dock at a base" uses a specific verb and resource, clearly identifying the action and distinguishing it from siblings like 'undock' or 'travel'.

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 dock versus using alternatives such as 'travel' or 'jump'. The intended context is only implied by the verb, with no exclusions or 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?

The description discloses significant behavioral traits beyond the minimal readOnlyHint=false: it takes 80 seconds, prevents other actions until resolved, returns a narrative rather than structured data, and can have three distinct outcomes (real intel, nothing, spy spotted). This greatly enriches the annotation-only data.

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

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

The description is a single sentence packed with essential information (prerequisites, time cost, blocking, return format, outcomes). While slightly dense, every element earns its place and it efficiently conveys all needed details without redundancy.

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

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

Given the tool's simplicity (one parameter) and lack of output schema, the description is remarkably complete. It covers prerequisites, timing, blocking, return type, and outcome variability, even mentioning example intelligence types. There are no significant gaps.

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

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

The input schema already fully documents the single parameter (session_id) with 100% coverage, so the description need not elaborate. The description adds no parameter-specific context, and the parameter is straightforward, so the baseline score of 3 is appropriate.

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

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

The description clearly states the specific action (send a spy) and target (station you're docked at), with distinct prerequisites and expected outcome. It unambiguously differentiates this from sibling tools by mentioning using the faction's Espionage HQ, making the purpose unmistakable.

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

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

It explicitly enumerates conditions for use: requires faction membership, an active Espionage HQ facility, and being docked at the target station. It also notes the 80-second duration and blocking behavior. However, it does not name alternative tools or explicitly say when not to use it, so it stops short of the highest bar.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds useful context about output: 'Shows available quantity, total cost, and price breakdown across sellers.' It also clarifies that the tool accepts item names, which goes beyond the schema. No contradiction with annotations.

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

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

The description is a single sentence with a parenthetical example, front-loading the primary purpose and including key details without wasted words.

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

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

The tool has no output schema, but the description sufficiently explains return contents (available quantity, total cost, price breakdown). It lacks details on error cases or edge conditions, but for a read-only estimate tool, the provided information is adequate.

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

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

Schema descriptions cover all parameters, but the description enriches the meaning of 'item_id' by noting it can accept an item name (e.g., 'Iron Ore') in addition to an ID. This adds value beyond the schema's 'ID of the item' definition.

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

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

The description clearly states the tool's function: 'Preview what buying would cost without executing,' using a specific verb and resource. It also distinguishes itself from the sibling 'buy' tool by emphasizing it does not execute the purchase.

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 scenarios by saying 'without executing' and 'Read-only,' indicating it's for pre-purchase cost assessment. However, it does not explicitly name alternatives like 'buy' or state when not to use it, so it falls short of full guideline clarity.

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 rich behavioral details (e.g., dismantle returns 100% materials, repair costs 30% of build time, foundational facilities cannot be dismantled). However, annotations claim readOnlyHint=true and idempotentHint=true, which directly contradict the many mutating and destructive actions described (build, dismantle, set_name, etc.). This is an annotation contradiction.

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

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

The description is lengthy but well-structured with clear section headings (WILDLIFE RANCH, DISMANTLE, FACTION SHIP GARAGE, REPAIR, PACKAGE JOBS). It front-loads the general purpose and action list, then dives into specific flows. The density is justified given the tool's 31-action scope, but it is still more verbose than ideal.

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

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

Given the tool's 31-action surface area and lack of an output schema, the description covers the most complex sub-flows thoroughly (ranch, dismantle, garage, repair, package jobs). It points to 'help' for full documentation, and the schema covers remaining parameter details. Some actions like transfer and list_for_sale get only brief mentions, but the overall completeness is high.

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

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

The input schema already covers all 34 parameters with descriptions, meeting the 100% coverage baseline. The description adds extra semantics for several parameters, such as species for ranch buildings, package_ids for sourcing materials directly, and cull_target for herd maintenance, going beyond the schema's basic definitions.

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

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

The description opens with 'Manage facilities at stations' and enumerates 31 specific action names, making the tool's scope unmistakable. It clearly distinguishes itself from sibling station/base tools by listing facility-only actions like build, dismantle, and ranch_set_cull.

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 workflow-level guidance for major sub-features: ranching (with survey_system as a data source), dismantle packaging mechanics, faction ship garage progression, and repair costs. It doesn't explicitly state when NOT to use this tool versus alternatives, but it includes enough context for typical use cases.

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

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

Annotations already indicate a write operation (readOnlyHint=false), and the description adds meaningful context by stating that it requires a specific permission and that it 'ratifies the alliance on both sides'. This discloses the side effects beyond the simple read-only flag.

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, compact sentence with essential details in parentheses—permission, effect, how to find proposals, and input format. Every phrase earns its place with no filler or redundancy.

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

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

For a simple two-parameter action, the description covers permission, the prerequisite of finding proposals, input formats, and the outcome of ratification. It does not describe the response format, which is a minor gap given the lack of an output schema, but the core behavior is fully specified.

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

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

Schema coverage is 100% with clear descriptions for both session_id and target_faction_id. The description repeats the faction ID/tag format already present in the schema but adds no new semantic meaning beyond what the schema provides, so it stays at the baseline.

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

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

Description uses specific verb 'Accept' and resource 'pending alliance proposal', clearly distinguishing from sibling tools like faction_propose_ally and faction_remove_ally. It names the exact action (accepting a proposal) and the object, leaving no ambiguity.

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

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

Provides explicit guidance: requires 'manage_diplomacy' permission, tells the agent to use 'faction_info' to see pending proposals, and notes the input accepts either faction ID or a 4-character tag. This clarifies when and how to invoke the tool, including a practical prerequisite step.

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

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

The annotation readOnlyHint=false already indicates this is a mutating operation, and the description's verb 'accept' reinforces that. The description adds the prerequisite of having a pending invite, which is useful. However, it does not disclose what happens on success (e.g., joining the faction, side effects) or failure, leaving some behavior undocumented.

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 redundant: 'alias for join_faction' appears twice, and the parenthetical phrasing is repetitive. While short, it wastes words and could be condensed to a single clear sentence. This lacks the crispness expected for good structure.

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

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

Given the tool is a simple mutation with no output schema and two well-documented parameters, the description provides the essential precondition (pending invite) and alias equivalence. However, it does not explain what the response or result looks like, leaving some ambiguity about the success/failure behavior. For a low-complexity tool, this is adequate but not comprehensive.

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

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

The input schema covers both parameters (faction_id and session_id) with descriptions, achieving 100% schema coverage. The description adds no additional parameter-level context, so it relies entirely on the schema. Per the baseline for high schema coverage, a score of 3 is appropriate.

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

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

The description clearly states the tool's action: 'Accept a faction invitation.' It also explicitly identifies itself as an alias for join_faction, which distinguishes it from sibling tools like faction_decline_invite and faction_invite. The verb and resource are specific and unambiguous.

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

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

The description provides clear context: you must have a pending invite from the faction. It also explains the alias relationship with join_faction, implying both are interchangeable. However, it does not explicitly mention alternative actions like declining an invite or when not to use this tool, leaving a slight 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?

The description goes beyond the annotation (readOnlyHint=false) by explicitly stating the war-ending consequence, permission requirement, and input flexibility (faction ID or 4-character tag). This gives the agent essential behavioral context for a write operation with meaningful 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, efficient sentence with a parenthetical packed with essential details. It front-loads the action and includes necessary context without redundancy, earning its place with every 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?

Despite having no output schema, the description covers the purpose, permission, effect, how to find proposals, and accepted input format. For a 2-parameter tool with this action's simplicity, the description fully equips an agent to select and invoke it correctly.

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

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

The schema already describes both params at 100% coverage, including 'Faction ID or 4-character tag' for target_faction_id. The description adds no new parameter semantics beyond an example 'NOVA', which is minor. Baseline 3 is appropriate given schema coverage is high.

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

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

The description clearly states the verb 'Accept' and the resource 'a peace proposal', which precisely identifies the tool's function. It distinguishes itself from sibling tools like faction_propose_peace by focusing on acceptance, and mentions specific details (faction ID/tag) that uniquely scope its operation.

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

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

The description provides explicit usage context: requires `manage_diplomacy` permission, ends the war, and instructs to use faction_info for pending proposals. While it doesn't explicitly state 'when not to use', it gives enough situational guidance to select this over alternatives, especially given no direct sibling 'decline' tool exists.

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 readOnlyHint=false confirming a mutation, the description adds valuable context: refunds escrowed credits and items to faction storage, restricts cancellation when a player is active, and requires manage_treasury permission. This goes well beyond the minimal annotation signal.

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

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

The description is two sentences, front-loaded with the primary action and outcome. The parenthetical adds necessary clarification about refunds, conditions, and permissions without excessive verbosity. Minor redundancy exists but does not detract from 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?

The description covers the operation's effect (refund), constraints (active mission, permission), and all required parameters are fully documented in the schema. No output schema exists, so the lack of return-format details is acceptable for a targeted cancellation 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?

Both parameters (session_id and template_id) have full descriptions in the schema, achieving 100% coverage. The description adds no extra parameter details, so it meets the baseline of 3 but does not exceed it.

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

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

The description clearly states the action (cancel), the resource (posted faction mission), and the outcome (refund escrowed rewards). This distinguishes it from sibling tools like abandon_mission or decline_mission, which handle different mission states.

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 clear usage context by specifying the action and a key condition (cannot cancel if a player is actively working on it). It does not explicitly reference alternative tools, but the context is enough to guide an agent in selecting this tool over similar ones.

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

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

Beyond the readOnlyHint:false annotation, the description discloses credit escrow, item delivery to faction storage, duplicate order merging, fuel routing, private listing requirements, and bulk limits. This is substantial behavioral context that goes well beyond what annotations provide.

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 dense but somewhat run-on, with multiple clauses and parentheticals. Every piece adds value, but the single long sentence could be better structured with separate sentences for readability.

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

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

Given the tool's complexity (7 parameters, bulk mode, private mode, special fuel handling), the description covers all key aspects needed for correct invocation. It does not mention the return value, but the absence of an output schema makes this a minor gap in an otherwise comprehensive description.

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

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

Although the schema already describes each parameter, the description adds important nuance: item_id accepts item names, the special 'fuel' order behavior, and the interaction between bulk orders and top-level fields. These details enhance the schema descriptions.

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

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

The description clearly states the tool's function: creating a faction buy order funded by the faction treasury. It distinguishes this from generic buy orders by specifying faction-specific features (treasury funding, delivery to faction storage, fuel reserve routing, Company Store private listings).

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

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

The description provides clear context for when to use this tool (faction purchases, fuel orders, private listings) and mentions required permission. However, it does not explicitly name alternative tools (e.g., create_buy_order) for personal orders, so it stops short of full alternative-based guidance.

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

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

The annotations declare readOnlyHint=true and idempotentHint=true, but the description claims a create operation, which is a mutation. This is a direct contradiction, making the behavioral profile misleading. The description does not resolve the contradiction and provides no additional clarity about 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, front-loaded sentence that includes all key constraints. Every part earns its place, with no redundant or extraneous text.

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

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

The schema covers parameter details well, but the description lacks any mention of the permissions parameter's effect or the broader role-creation context. The annotation contradiction further reduces completeness, as the agent cannot trust whether this is a safe read or a mutation. It is minimally viable but with clear gaps.

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

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

Schema description coverage is 100%; all four parameters have meaningful descriptions. The description reinforces the priority rule (defaults and required priority threshold) but adds little beyond what the schema already provides. Therefore it meets the baseline for high coverage but does not compensate further.

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 a custom faction role'. The verb 'create' and the resource 'faction role' are clear and distinguish it from sibling tools like faction_edit_role and faction_delete_role.

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

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

The description provides clear usage context by specifying the required `manage_roles` permission and the priority constraint (2-99, must exceed new role's priority). It does not explicitly mention when not to use the tool or name alternatives, but the prerequisites are clearly 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?

Discloses key behaviors: items escrowed from faction storage, credits go to faction treasury, listing fee deducted, duplicate orders merge quantities, and private listings have separate caps. Since annotations only provide readOnlyHint:false, this additional context is valuable and consistent.

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

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

The description is moderately long but each sentence adds unique value. It front-loads the purpose and then details special behaviors. Slightly dense with parentheticals, but not wasteful.

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

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

Despite lacking an output schema, the description covers purpose, permissions, escrow/credit behavior, duplicate handling, private listing requirements, and bulk mode. This is complete for a complex tool with 7 parameters and multiple modes.

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

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

Schema covers all parameters, but the description adds crucial semantics: item names are accepted in addition to item IDs, and top-level fields are ignored when the orders array is provided. This goes beyond the schema's basic field descriptions.

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

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

The description clearly states the action (create a sell order), the resource (faction storage), and differentiates from personal sell orders via 'on behalf of your faction.' It also mentions bulk mode and private listing, distinguishing it from sibling tools like faction_create_buy_order.

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

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

Provides clear usage context: requires manage_treasury permission, explains when to use private:true (Company Store listing), and describes bulk mode. It doesn't explicitly name alternatives (e.g., use create_sell_order for personal orders), but the faction-specific scope is clear.

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

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

Annotations only indicate readOnlyHint=false, so the description adds valuable behavioral context: it requires specific permission, puts both factions into a war state, tracks kills, and notifies targets. This goes beyond a simple mutation flag and informs the agent of significant side effects, though it could also mention reversibility or cooldowns.

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 of about 28 words, front-loaded with the core action and using parentheticals to convey permission, effects, and input format. It is dense but not overly verbose; a slight restructuring could improve readability, but it earns most of its place.

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

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

For a state-changing tool with no output schema, the description does a good job explaining success effects (war state, kill tracking, notifications) and the permission requirement. However, it omits potential edge cases such as already being at war, alliance restrictions, or what the response contains, leaving the agent to infer some important operational details.

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

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

The input schema already describes all parameters with 100% coverage, including the same example tag 'NOVA' for target_faction_id. The description does not add new parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description opens with the specific verb 'Declare war' and the resource 'another faction', making the tool's purpose immediately clear. It also explains the outcome ('Both factions enter war state') and distinguishes it from related diplomacy actions like faction_propose_peace or faction_set_enemy.

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 states a required permission ('manage_diplomacy') which provides important context for when the tool can be used. However, it does not explicitly mention when to avoid it or point to alternative tools for similar actions (e.g., faction_set_enemy). Thus, guidance is clear but lacks 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?

The description says 'Decline' and 'Removes the pending invitation,' which are mutations, but the annotations declare readOnlyHint: true. This is a direct contradiction. No additional behavioral context is provided, making the transparency poor.

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 a helpful parenthetical clarification. It is concise, front-loaded, and contains no unnecessary words.

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

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

The tool is simple with two parameters and no output schema, so the description is mostly adequate. However, the contradiction with annotations leaves behavioral expectations unclear, and it does not mention edge cases like what happens if no invitation is pending. Given the simplicity, a score of 3 is appropriate.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (session_id and faction_id). The description adds no extra semantic meaning beyond what the schema provides, warranting the baseline score of 3.

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

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

The description clearly states the action: 'Decline a faction invitation' with a specific resource and verb. It also clarifies the effect by saying 'Removes the pending invitation,' which distinguishes it from related tools like faction_accept_invite or faction_withdraw_invite.

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

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

The description implies when to use the tool (when you want to decline a faction invitation), but it does not provide explicit alternatives or exclusions. Given the sibling list contains many faction invite-related tools, some differentiation would be helpful, but the core context is clear.

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

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

The description clearly states "Delete" which is a mutation, but the annotations mark readOnlyHint=true and idempotentHint=true. This is a direct contradiction. Even though the description discloses permissions and reassignment, the contradiction forces a score of 1 per the rules.

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, compact sentence that packs all necessary constraints into a parenthetical. There is no wasted text; every clause adds behavioral 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 destructive action, the description covers permissions, default-role exclusion, member reassignment, and priority requirement. Without an output schema, it gives sufficient context for an AI agent to understand the operation's effects, though the contradictory annotation reduces trust.

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

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

Schema coverage is 100% with both parameters already described in the schema. The description adds no additional parameter-specific information, so it meets the baseline but does not exceed it.

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

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

The description opens with "Delete a custom faction role," which is a specific verb and resource. It clearly distinguishes from siblings like faction_create_role and faction_edit_role by focusing on deletion, and it specifies "custom" to exclude default roles.

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 clear conditions for use: requires manage_roles permission, cannot delete default roles, and priority constraint. It implicitly indicates when not to use (for default roles) and mentions reassignment consequences, though it does not explicitly name alternative tools.

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

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

The description contradicts the annotations. It states 'Permanently removes the room' which is a destructive write operation, while annotations declare readOnlyHint=true and idempotentHint=true. This is a serious inconsistency that misleads the agent into thinking the tool is safe and read-only.

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 concise sentence that packs the core action, the permanence consequence, and the permission requirement. No wasted words.

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

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

The description covers the essential aspects: what is deleted, permanence, and permission. However, the annotation contradiction undermines the overall contextual reliability, making the tool's true behavior ambiguous for the agent. Without an output schema, the description is otherwise sufficient.

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

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

The input schema has 100% coverage with descriptions for both room_id and session_id. The description does not add further parameter semantics beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Delete a room') and the resource ('your faction's common space'). It distinguishes this from sibling tools like faction_visit_room and faction_write_room by specifying the destructive nature.

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

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

It provides a clear context (deleting a room) and a permission requirement (manage_facilities), but it does not explicitly mention when to use this tool versus alternatives or when not to use it. The permission hint is useful but incomplete.

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 adds behavioral context beyond annotations: 'Tracked in the audit log' and permission info ('Any faction member can deposit credits'). The readOnlyHint=false matches the write operation, so no contradiction.

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

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

Two concise sentences with the main action front-loaded and useful context in parentheses. No wasted words.

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