SpaceMolt

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

With only readOnlyHint=false in annotations, the description carries the behavioral burden and does so thoroughly: it explains cargo retention, courier good reclamation, smuggling debt persistence, wallet-capped charges for other missions, expiry equivalence, and concrete debt settlement paths.

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 main action is front-loaded, and most of the dense parenthetical content earns its place by explaining non-obvious consequences. It is longer than typical but largely justified by the complexity of debt and cargo rules.

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?

There is no output schema and minimal annotations, so the description must explain consequences and follow-up behavior. It covers removal, cargo handling, debt rules, expiry, and the two ways to settle debt, making it complete enough for an agent to call 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%, so mission_id and session_id are already documented in the schema. The description adds no parameter-level detail beyond what the structured schema provides.

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

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

The description opens with a specific verb and resource: 'Abandon an active mission.' It immediately clarifies scope by saying the mission is removed from the active list, which distinguishes it from mission completion/acceptance siblings even though it does not name them directly.

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 by 'active mission,' and the description gives important post-abandon consequences. However, it does not explicitly compare this tool against alternatives such as decline_mission or complete_mission, so an agent must infer when abandoning is preferable.

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

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

Annotations only declare readOnlyHint=false, so the description must carry the behavioral load, and it does: it discloses location preconditions, capacity limits, resource requirements, and exclusivity rules that are nowhere in the structured data. It stops short of stating what happens on rejection (error vs. silent failure) or where the accepted mission surfaces afterwards, which is the remaining gap.

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

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

Purpose is front-loaded and every clause in the parenthetical is a distinct, non-redundant constraint. The single dense parenthetical of six unrelated rules is harder to scan than a short list would be, which costs it a point, but there is no filler.

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

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

No output schema exists, so return values need no explanation, and for a 3-parameter mutation with one required field the prerequisite coverage is strong. The one thing an agent might still want is confirmation of the post-accept state (that the mission becomes an active mission visible via get_active_missions).

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 already documents mission_id, template_id and their precedence over one another. The description adds only the practical pointer that mission IDs come from get_missions; it adds no semantics about the mission_id vs template_id distinction that the schema does not already cover, so baseline 3 applies.

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

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

States a specific verb and resource ("Accept a mission from the mission board") and immediately scopes it against siblings: get_missions to browse, and implicitly complete_mission/decline_mission/abandon_mission which handle other lifecycle stages. An agent can distinguish it without opening the schema.

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

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

Gives explicit when-to-use conditions (must be docked at the issuing base), the single documented exception (distress-response missions claimed by mission_id from anywhere), and names get_missions as the way to discover mission IDs. It also states the eligibility gates that determine whether a call should be attempted at all: 5 active-mission cap, courier cargo allowance, one restitution job maximum, faction posting race.

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 cover safety (readOnlyHint, idempotentHint), and the description adds genuinely new behavioral context: output depth scales with trading skill, results are limited to systems you have visited, and private faction orders, fuel sell orders, and untradeable contraband are filtered out. It stops short of cost, rate limits, or refresh/caching behavior, so not a full 5.

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 lead sentence and the parenthetical open by restating the same idea ('actionable trading insights' / 'Returns trading insights based on your trading skill level'), and the wall of exclusions in one long sentence is hard to scan. Nothing is wasted exactly, but the structure is redundant and dense rather than front-loaded and tight.

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?

There is no output schema, so the description carries the return-shape burden, and it does so adequately by enumerating insight categories and clarifying scope and filtering. It is nearly complete for a zero-argument read tool, with only the exact result format/pagination left unspecified.

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 only parameter is session_id, so the schema already carries the burden. 'No parameters needed' is useful for signaling there are no trade-specific arguments, though it is technically loose given session_id is required. Baseline 3 applies.

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

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

The first sentence names a specific verb and resource ('Get actionable trading insights at your current station') and the parenthetical enumerates what those insights contain (regional demand, price trends, arbitrage, station opportunities). It also implicitly separates itself from view_market by describing how it reads markets. The only weakness is the slightly vague umbrella term 'actionable trading insights' before the elaboration.

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 ('at your current station', 'no parameters needed') and it gestures at view_market as the reference view, but it never states when an agent should call this instead of view_market, get_trades, or get_map. No prerequisites or exclusions are given, so the agent must infer the call 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 only readOnlyHint=false in annotations, the description carries the burden and does so richly: knockout instead of death, what is restored (hull, shields, armor, crew, modules) versus genuinely spent (ammo, fuel, consumables), emergency warp not triggering, fleeing forfeiting, and the fact that results count only in arena_wins/losses/knockouts with no crime, reputation, or police effects. Error behaviors (player_not_found, challenge_locked, rule_*) are also disclosed.

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

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

Purpose is front-loaded and the per-action breakdown is well organized, with no obviously redundant sentences for an eight-action tool. It is nonetheless dense and long, and the waves/objective and knockout passages are run-on enough that some trimming is 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 complex multi-action tool with no output schema and only a single annotation, the description covers outcomes, notification behavior (arena_objective), stat accounting, XP caps, and the main error codes. An agent has enough to select the right action and anticipate the results without further documentation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantics: player_id must reference a visible, undocked pilot (else player_not_found), max_side_size=1 means a solo duel and 0 lets every eligible fleet member join, and challenge_id comes from the 'challenges' action. This meaningfully extends beyond the schema text.

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

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

The opening sentence names the specific resource and its defining scope: 'Consequence-free combat at an arena POI: challenge a pilot, fight on the normal battle engine, leave with ship and crew intact.' The action enumeration and the consequence-free framing distinguish it from real-combat siblings like battle, attack, and hunt without opening any schema.

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?

Each action is given clear triggering context (challenge an undocked pilot, accept/decline a pending challenge, status for live match state, challenges to list NPC challenges, fight to start one), which is strong per-action routing. It does not explicitly name an alternative tool or state when not to use arena instead of real combat, so it falls short of the 5 bar for 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?

Annotations only declare destructiveHint=true; the description goes far beyond by disclosing crime/bounty/reputation penalties, the reciprocal-attack tick rule, pirate dogpile behavior, siege mechanics, and specific error codes (invalid_target, target_docked, out_of_range, own_faction_station). This is rich behavioral context that annotations alone could never 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?

Front-loaded with the core action and target list, then progressively discloses mechanics and errors, so an agent can stop reading early. It is dense and mostly earns its length, though the reciprocal-attack rule is restated in the schema description and some siege/crime details border on redundant.

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 high-complexity, no-output-schema mutation tool, the description covers returns (attack response confirms engagement only) and points to the correct read tools (get_battle_status, battle_damage/battle_update notifications, get_battle_summary). An agent has everything needed to call it correctly and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful constraint semantics for target_id: valid ID classes, the requirement that the target be visible and at your current POI or in the active battle, and the consequences of invalid/unreachable IDs. It adds real meaning beyond the schema's type declaration.

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

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

States a specific verb (attack) and enumerates the exact resource classes (player, pirate, empire NPC, creature, station, intact prize) with a clear scope constraint (must be at your POI or already in your system's battle). It distinguishes itself from siblings like hunt, battle, and service_prize without the agent needing to open those schemas.

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

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

Explicitly covers when to use (target must be at your POI or already fighting in the battle), when NOT to re-issue it (already-fighting targets, with the reason it never fires an extra volley), and names alternatives ('battle' with action parameter for tactical control; 'hunt' equivalent for wildlife). Nothing is left to inference.

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

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

The description says the tool manages battles by maneuvering, targeting, changing stance, engaging, and self-destructing, with queued changes applied at the next battle tick. Those are state-changing battle operations, but the annotations declare readOnlyHint=true and idempotentHint=true, so the description directly contradicts the structured safety 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 front-loaded and uses an action list plus examples, which helps structure. But it is long and dense, and it repeats substantial schema content, especially around stance and boarding mechanics; that reduces conciseness even though the complexity of the tool justifies detailed guidance.

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

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

For a complex multi-action battle tool, the description covers action effects, queued-tick behavior, boarding restrictions, side selection, and several error cases well. It still does not describe the response shape despite having no output schema, and the annotation conflict leaves the structured behavioral context unreliable.

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 has 100% parameter description coverage, the description adds useful meaning beyond it: action-specific effects, no-tick queuing, own-faction side_id behavior, cloak-dropping on engage, boarding requirements, duplicate self_destruct handling, and concrete examples. Much of the stance and boarding detail is repeated from the schema rather than adding new information.

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, 'Manage your battle,' and enumerates the supported actions: advance, retreat, stance, target, engage, self_destruct, and help. It distinguishes this from the standalone reload command, but it does not clarify the boundary with sibling tools such as attack, self_destruct, get_battle_status, or get_battle_log.

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

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

It provides detailed per-action guidance and examples for choosing advance, retreat, stance, target, engage, and self_destruct, and explicitly routes reload to the standalone reload command. However, it lacks explicit when-not-to-use guidance against competing sibling tools such as attack or the standalone self_destruct command.

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

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

Annotations already indicate readOnlyHint and idempotentHint, so the safety profile is covered. The description adds useful behavior beyond annotations: it clarifies that listings are player-listed, that base_id can be either a Base ID or POI ID, and that the tool defaults to the current station.

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 main action is front-loaded and the details are grouped in a parenthetical. There is some redundancy between 'ships listed for sale' and 'player-listed ships for sale', but overall the description is compact and readable.

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 filtered listing tool with strong annotations and fully documented parameters, the description covers the essential inputs and selection behavior. It does not describe the output shape or pagination, but the absence of an output schema and the simple browse semantics make this 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?

Schema coverage is 100%, and the schema already documents each parameter adequately. The description mostly repeats what the schema states, such as base_id defaulting to the current station and filters for class_id and max_price. It adds little semantic value beyond that 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 a specific verb and resource: browsing ships listed for sale at a base. It distinguishes this from siblings like list_ship_for_sale (which sells a ship) and buy_listed_ship (which purchases one) by specifying this is a view of player-listed ships.

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 how to target a station: default to current base or pass base_id as either Base ID or station POI ID, and optionally filter by class_id or max_price. It does not explicitly mention when not to use it or name alternatives, but the read-only browsing 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?

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?

Annotations only declare readOnlyHint=false, so the description carries the real burden and does well: it discloses that tax is added to unit price, that instant fills avoid the listing fee, that auto_list incurs a 1% (or higher) fee, and that overflow goes to storage when cargo is full. It omits failure modes such as insufficient credits or order rejection, keeping it from a 5.

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?

Front-loaded with purpose, and every clause carries real information, but it is delivered as one long sentence with nested parentheticals (fees inside the instant-fill aside), which makes it harder to scan than a short bulleted split would be.

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

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

For a 5-parameter mutating trade tool with no output schema, it covers cost model, delivery destination, and partial-fill handling, which is what an agent needs before calling it. Missing are credit/precondition checks and any hint of the result shape after a partial or failed fill.

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 already 100%, so baseline is 3, but the description adds genuine meaning: item_id also accepts an item name (e.g. 'Iron Ore'), while the schema only documents IDs, and it explains the price/fee consequences of auto_list and the cargo-vs-storage distinction for deliver_to beyond the enum text.

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

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

States a specific verb and resource: buying items at market price from the station exchange, with instant-fill semantics. That distinguishes it from create_buy_order and sell in substance, though no sibling is named explicitly, so the agent must infer the boundary itself.

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

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

Gives conditional guidance for the two optional behaviors: use deliver_to=storage when sending straight to storage, and auto_list=true when unfilled quantity should become a buy order. It stops short of explicit 'use create_buy_order instead when...' routing, which is the main gap given how many order-related siblings exist.

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

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

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 say readOnlyHint=false, so the description carries the burden and does it well: credits go directly to the seller, the current ship is stored at the base, the purchased ship becomes active, wreck tow is released without moving the wreck, and already_towing is a named return. This is exactly the side-effect disclosure a mutation tool needs.

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 core action is front-loaded in the first sentence, with consequences and edge cases following in a parenthetical. The parenthetical is dense but every clause (skill fit, docking, tow, already_towing workaround) is actionable, so little is wasted.

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

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

For a mutation with no output schema, the description covers the financial flow, ship state changes and the notable error path. Only minor gaps remain, such as whether listing price is displayed before purchase or what happens to unsold listing state, but nothing critical to correct invocation 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?

Schema description coverage is 100% and listing_id even points to browse_ships, so the schema does the heavy lifting. The description adds no extra meaning about listing_id or session_id, which matches the baseline 3 for a fully documented 2-param 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?

States a specific verb and resource (purchase a ship from the exchange) and implicitly distinguishes itself from browse_ships, list_ship_for_sale and cancel_ship_listing by being the transaction step. An agent can identify the operation without opening the schema.

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?

Lays out concrete preconditions: fitted CPU and power must meet Engineering skill, must be docked at the same base, and the seller must refit an incompatible listing. It also names the recovery path for the already_towing error via storage withdraw. It stops short of explicitly contrasting with commission_ship or buy_ship_license, so it doesn't reach 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 supply only readOnlyHint=false, so the description carries the full burden and does so thoroughly: treasury-funded cost scaling per tier (T1=1M through T5=50M), a 10% per-build royalty routed to the empire treasury or split among pirate managers, and the fact that the license waives the hull's empire reputation requirement but not piloting level. These are non-obvious economic and permission consequences an agent could not infer from structured fields.

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 core purpose is front-loaded, but the remainder is a single dense block of nested parentheticals covering cost tiers, royalty splits, downstream commissioning, ally shipyard access, resale rights, and reputation waiver. Several of these (ally_shipyard_access, resale) are tangential to the act of buying a license and dilute scannability for an agent.

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

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

For a two-parameter, no-output-schema mutation tool, the definition covers prerequisites, cost, recurring obligations, exclusions, and the resulting build workflow. Nothing an agent needs in order to decide whether to call it, or to explain the consequences to a user, 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?

Schema coverage is 100% and both parameters are already documented, including the 'from catalog type=ships' example for ship_class. The description reinforces the concept of 'a specific ship design' but adds no syntax, format, or validation detail beyond the schema, 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 opens with a precise verb+resource: 'License a specific ship design so your faction can build it at its own stations.' It immediately separates this from adjacent tools by explaining that the license precedes a faction-funded commission_ship build, so an agent can distinguish it from commission_ship, browse_ships, or catalog without opening the schema.

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 explicit exclusions ('not starter, prestige, or pirate boss flagships'), a prerequisite ('Requires the ManageTreasury permission'), the affordability constraint, and the follow-on path ('commission_ship with fund_from_faction=true'). It also notes the pirate-hull case requires no stronghold, which is exactly the kind of when/when-not guidance that selects correct invocation.

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

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

Annotations only declare readOnlyHint=false, so the description carries the behavioral burden and does so richly: it details the refund outcome in each phase (pre-sourcing refunds funds/labor/fee, post-sourcing refunds fee plus 50% labor), where materials go (station vs faction storage), and the faction cancellation policy. This is strong mutation consequence 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?

Front-loaded with the core statement before the parenthetical detail, and each parenthetical clause describes a distinct refund scenario that earns its place. The nested run-on parenthetical is dense and slightly hard to parse, costing the top mark.

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

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

For a mutation tool with no output schema, the description fully covers the consequences an agent must anticipate (refunds, material returns, faction policy). Nothing needed to call it correctly 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?

Schema description coverage is 100% and both parameters (session_id, commission_id) are already documented in the schema. The description adds no syntax or format detail about parameters, so the baseline 3 applies.

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

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

States a specific verb (cancel) and resource (ship commission) plus a precise scope qualifier: 'pending or in-progress'. An agent can distinguish it from commission_quote, commission_ship, commission_status, and cancel_order without opening any schema.

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?

Clearly establishes the condition under which cancellation is valid ('a commission that hasn't finished yet' / 'pending or in-progress'), which is real usage context. It does not, however, name alternative commission tools or explicitly exclude finished/other states by tool name, so no sibling routing.

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 from annotations, the description carries real weight: it discloses the required permission (ManageBases), the timing window, the refund of the escrowed jump resource, and an explicit exclusion case (isolated jumps). This is exactly the kind of side-effect and precondition detail annotations cannot express.

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 dense sentence with the core action front-loaded and the constraints in a parenthetical. Every clause earns its place, though the nested conditions make it slightly heavy to parse.

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

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

For a one-parameter mutation with no output schema, the description covers permission requirements, the timing constraint, the refund side effect, and an exclusion case. Only the exact failure/response behavior outside the window is left implicit.

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?

Only one parameter (session_id) and schema coverage is 100%, so the schema fully documents it. The description adds no syntax or format detail beyond the schema, matching the baseline 3 for high coverage.

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

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

Names a specific verb (cancel), a specific resource (faction mobile-base jump), and a specific state (during preparation). It clearly distinguishes itself from the sibling jump_faction_mobile_base and move_faction_mobile_base.

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

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

Gives concrete conditions for use: only during the 90-tick preparation window, and not for isolated jumps. It also states the ManageBases permission prerequisite. It stops short of naming an alternative tool to use outside these conditions, so it is a 4 rather than 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 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 (readOnlyHint=true, idempotentHint=true) already declare the safety profile, and the description adds genuinely non-obvious behavior beyond them: a facility lookup also returns the recipe it runs, facility search matches recipe items, pagination defaults to 1/20 with max 50, and commissionable=true carries specific prerequisites (auth, docked at shipyard, tier/empire/license/skill/reputation checks). 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 core purpose is front-loaded and every clause carries information, but the entire parameter guide is a ~130-word run-on parenthetical with nested parentheses, dashes, and em-dashes that is genuinely hard to parse. Restructuring as a short bulleted list or one sentence per parameter would keep the density while making the modes legible.

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 an 11-parameter tool with no output schema, the description thoroughly covers the trickiest behavior (commissionable's requirement chain) and the facility special cases, and the read-only annotations lower the burden on safety disclosure. Gaps remain: no return-format guidance, no clarification of the class/category overlap, no mention of standalone tier/empire filters, and no error or auth-failure behavior.

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

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

Schema coverage is 100%, setting a baseline of 3. The description adds real cross-parameter meaning the schema lacks: the facility search-scope extension, what commissionable actually verifies, and pagination defaults. However, it omits the standalone class, tier, and empire filters (only alluded to inside the commissionable explanation) and otherwise largely restates schema text.

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?

Uses a specific verb ('Browse') plus a concrete resource ('game reference data') with all five categories enumerated (ships, skills, recipes, items, facilities) and describes the filtering/pagination modes. This distinguishes it from action siblings like attack or commission_ship, and even from the similarly named browse_ships, since it covers multiple data types as a read-only catalog.

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 conveys the tool's context (reference data browsing with list vs. by-ID modes) and implies when the commissionable filter applies, but it never explicitly names alternatives or states when-not-to-use. With roughly 200 siblings including browse_ships, get_ship, get_skills, get_guide, and facility, explicit exclusionary routing would materially help an agent select correctly.

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?

Annotations mark this as a mutating operation (readOnlyHint=false), and the description adds concrete behavioral details: minimum crew assignment, leaving at least one crew on the active ship, and the crew_disposition effects. It does not cover failure modes or costs, but it goes well beyond the minimal annotation.

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

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

The opening phrase is clear, but the description is a dense parenthetical block. The crew_disposition explanation is nearly redundant with the schema description, so not every part of the text earns its place. It could be trimmed or split into structured sentences.

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 mutating tool with no output schema, the description covers preconditions, timing windows, destination constraints, and crew mechanics—enough for an agent to invoke it correctly. It leaves return values and error behavior unspecified, but these are not required given the schema richness.

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 already explains crew_disposition defaults, faction_reserve behavior, and accessible destination. The description mostly restates these facts, adding only a small amount of contextual emphasis on location and destination access.

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: 'Assign prize crew and begin recovery of an intact captured ship.' This unambiguously identifies the tool's action and target, and the prize-specific terminology distinguishes it from generic siblings like 'claim' and related tools like 'service_prize.'

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 clear preconditions: same POI, out of combat, exclusive versus public window, and an accessible destination station. It does not explicitly name alternative tools or say when not to use it, but the conditions strongly imply the appropriate usage context.

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

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

Annotations only say readOnlyHint=false, so the description carries the behavioral load and does it well: it discloses the ongoing cost (1 fuel per tick), the visibility effects on passive views, the counterplay condition (an active scan exceeding total scan defense), and the combat interaction. The cloak-strength formula and the explicit caveat that sensor dampeners add separate scan reduction not reflected in the reported value are exactly the kind of non-obvious detail an agent could otherwise mis-model.

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 action is front-loaded in the first three words, and nearly every clause carries operational information. The cost is structural: the entire body is one long parenthetical, which makes the fuel cost and battle restriction harder to scan than they should be.

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?

There is no output schema, and the description does enough to compensate by explaining what the reported cloak strength represents. It leaves minor gaps: it does not say what the tool returns on toggle, nor what the failure mode looks like when no cloak module is installed.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning at all, and it misses a real ambiguity the schema leaves open: 'enable' (boolean) and 'quantity' (1/0) are alternative encodings of the same action with no stated precedence when both are supplied.

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?

Opens with a specific verb and resource ('Toggle cloaking device') and immediately narrows the concept to a concrete capability rather than restating the name. It is clearly distinguishable from siblings like scan, espionage, attack, or battle because it explains what cloaking does relative to those systems.

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

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

Gives hard prerequisites (needs a cloak module or integrated cloak) and explicit when-not conditions: you cannot engage while in_battle, and attacking or engaging drops the cloak. It also names timing windows where toggling is legal (mid-jump, mid-travel, Pathfinder drift). It does not route the agent to any alternative sibling for stealth-adjacent needs, which keeps it below 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 already declare readOnlyHint and idempotentHint, so the safety profile is known. The description adds behavioral details beyond the flags: it returns pricing and requirements, previews partial-sourcing totals, and explicitly disclaims order placement. This gives the agent confidence the call is non-mutating and explains the effect of each preview mode.

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 packs the core purpose, the two relevant boolean modes, and the critical no-order note into one compact sentence. It is front-loaded with the main action, and every clause carries information with no filler 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?

For a read-only quote tool with no output schema, the description provides enough invocation context: purpose, two modifier flags, and the no-order guarantee. It does not detail the exact response fields, but 'detailed pricing and requirements' plus the parameter explanations is adequate for an agent to call it correctly. Both required parameters are clear from the schema.

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

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

Schema coverage is 100%, so every parameter already has a schema description and the baseline is 3. The description raises this by explaining the behavioral meaning of source_missing_materials and bare_hull in terms of cargo contribution, yard sourcing, and module loadouts. It adds why those booleans matter rather than just their type.

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

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

The description names a specific verb and resource ('Get a cost estimate for commissioning a ship') and immediately clarifies the tool's output as detailed pricing and requirements. The closing 'Does not place an order' differentiates it from siblings like commission_ship, so an agent can tell it apart without opening the schema.

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

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

The description clearly establishes the tool as estimation-only with 'Does not place an order', acting as a when-not signal. It also explains when to set source_missing_materials and bare_hull, giving context for the two conditional modes. It stops short of explicitly naming sibling alternatives like commission_ship or commission_status.

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 supply only readOnlyHint=false, so the description carries the behavioral burden and does so thoroughly: costs (labor plus yard fee, material sourcing charged only on the deficit), where materials are drawn from (cargo then station storage; ally faction storage), who pays (faction treasury/royalty, ally's treasury, faction-funded stations don't market-source), and the ManageTreasury permission requirement. It also discloses the asynchronous completion signal ('On completion the server pushes ship_commission_complete'), which no schema field conveys.

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 carries substantive information, but it is delivered as one long run-on paragraph with a nested parenthetical, making it hard to scan for the branch that applies to the caller. Several clauses (default loadout, flag exclusivity) partially duplicate the schema descriptions, so the density is higher than strictly necessary.

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 six-parameter mutation tool with no output schema, the description covers the full decision space: allowed ship types, module loadout behavior, all three payment modes and their conflict, faction and allied-station funding paths with permission prerequisites, the quote-before-commission pattern, and how completion is signaled. Nothing an agent needs in order to call it correctly appears to be 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?

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: fund_from_faction is framed as required at your own faction station and rejected elsewhere, the ally case is described in terms of which licenses, storage and treasury are used, and the bare_hull consequence ('ships arrive fitted' vs hull only) is spelled out in context. The flag-exclusivity rule is reinforced rather than merely restated.

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

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

States a specific verb and resource ('Commission a ship to be built at this shipyard') and immediately clarifies it places a build order at the current base's shipyard, distinguishing it from siblings like commission_quote, commission_status, cancel_commission and supply_commission. It also carves out an explicit exclusion (pirate boss flagships are capture-only), which removes a whole class of wrong invocations.

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

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

Gives explicit mode-selection guidance: at empire/NPC yards choose credits-only (default), provide_materials=true, or source_missing_materials=true, and explicitly forbids combining the two material flags. It names the alternative workflow ('Use commission_quote with the same bare_hull and source_missing_materials choices') and states that faction stations must use fund_from_faction=true, plus the allied-faction access conditions and mobile-base exclusion.

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 aligns with those by describing a read-only status query. It adds substantial behavioral detail beyond the annotations: field semantics for materials, omitted keys meaning zero, the pending→building lifecycle, delivery into the fleet, and the commission disappearing from the list once complete.

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 core purpose is front-loaded, and every included detail is useful, especially because there is no output schema to carry return-value semantics. The description is dense and slightly unwieldy as one large parenthetical block, but it earns its length by documenting edge cases and lifecycle behavior.

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

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

With no output schema present, the description compensates thoroughly by explaining the meaning of key response fields, zero-value omissions, base_id filtering, lifecycle progression, and the completion signal. For a status-checking tool with read-only annotations, this is complete enough for an agent to call and interpret the result 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 the schema already documents both session_id and base_id. The description repeats the base_id filter meaning rather than adding new parameter-level detail, though the detailed materials terminology applies to the response object, not to the input 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 opens with the specific verb-resource pair 'Check the status of your ship commissions,' which clearly identifies what the tool does. It is easily distinguished from related siblings like commission_ship, supply_commission, and cancel_commission because it focuses on observing active orders, not creating, supplying, or canceling them.

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

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

The description makes the primary use case clear: checking active commission status, with an optional base_id filter. It does not explicitly name alternatives or state when not to use this tool, but the context of status checking is unambiguous across a large sibling list.

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

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

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?

Despite minimal annotations (only readOnlyHint=false), the description discloses extensive behavioral details: reward sources (faction reserved rewards vs empire treasury), treasury shortfall effects, wallet limit impact, restitution debt reduction, error returns (wreck_not_here), and the need for a tow claim. This far exceeds what the 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 a single dense paragraph but front-loads the core action. Every sentence carries useful information, though the block could be better organized with bullet points. It is appropriately sized for the tool's complexity.

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

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

Given the lack of an output schema, the description compensates by explaining return values (credits_earned, credits_promised, credits_shortfall) and error conditions (wreck_not_here). It provides a complete picture of what to expect when calling 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?

Both parameters have full schema descriptions (100% coverage), so the schema already defines mission_id and session_id. The description does not add any additional meaning or constraints for these parameters, making the baseline score appropriate.

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

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

The description states a specific verb-resource pair: 'Complete a mission and claim rewards.' It is clearly distinct from accept_mission, abandon_mission, and get_missions, though it does not explicitly name or contrast with any sibling tool.

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

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

It gives clear preconditions ('Mission objectives must be fulfilled') and explains special cases like community missions ('call repeatedly as you gather materials') and wreck turn-ins ('Use release_tow, then tow the wreck again'). However, it does not explicitly state when to choose this over accept_mission or abandon_mission.

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 behavioral burden and does so extensively: jobs run over ticks, notifications are emitted, inputs are escrowed, outputs are delivered to storage, cancellation refunds unconsumed inputs, workshop jobs pause on undock, and several failure modes are named. It does not contradict the mutating annotation.

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

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

The purpose and key constraints are front-loaded, but the description is extremely long, dense, and parenthesis-heavy, mixing core usage, edge cases, legacy transport notes, and repeated package rules. It is comprehensive but not concise, and the transport-specific legacy action note is especially likely to distract.

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 mutating tool with many modes, the description covers required docked state, routing, costs, cancellation, retargeting, bulk jobs, package inputs/outputs, and dry-run behavior. No output schema exists, but the description sufficiently explains return behavior and notifications.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds workflow-level meaning: quantity is rounded to production runs, presets choose routing strategies, deliver_to affects permissions and retargeting, package_ids require exact pooled contents, and dry_run previews without spending. Much of this is also present in the schema descriptions, which keeps it from being fully additive.

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: queue a crafting job, with auto-routing and hand-crafting behaviors. It clearly distinguishes crafting from sibling operations like recycle and describes exploration via calling craft without recipe_id.

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

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

It explicitly states preconditions such as being docked, storage requirements, and when auto-routing presets or facility_id apply. It also spells out alternatives and special modes: use recycle to reverse a recipe, call with no recipe_id to list jobs, job_id to cancel, job_id plus deliver_to to retarget, and dry_run to preview.

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 while the description describes creating a new document, a state-changing write. This is a direct contradiction that would mislead an agent about the tool's side effects. The otherwise useful details (tradeable, no cargo space, max sizes) cannot offset a safety-relevant 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?

Single-sentence-plus-parenthetical structure is efficient, but the opening 'Create a new note document (Creates a tradeable text document...)' redundantly restates the verb and resource. Information is front-loaded but includes some waste.

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

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

For a low-complexity creation tool with no output schema and full schema coverage, the description covers what a note is and key constraints (docking, cargo). It remains incomplete on how it differs from write_note and, critically, on its actual write semantics given the conflicting annotations.

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

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

Schema description coverage is 100%, so all three parameters are documented in the schema. The description restates the same max-length limits (100 title chars, 100,000 content chars) already in the schema, adding no new parameter meaning. Baseline 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?

States a specific verb+resource ('Create a new note document') and elaborates what a note is, which is clear. However, it never distinguishes itself from close siblings like write_note, read_note, or get_notes, so an agent cannot disambiguate the intended tool from the description alone.

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

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

The description gives a prerequisite ('Requires docking') but no when-to-use guidance or alternatives. With both create_note and write_note present in the sibling list, the absence of any routing advice is a real 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 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?

Goes far beyond the lone readOnlyHint=false annotation: discloses permanence, no refund, the ManageBases permission requirement, and a full list of preconditions that would otherwise cause failures. This is exactly the destructive-operation context an agent needs before calling.

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?

Front-loads the action, then packs prerequisites and consequences into one dense parenthetical. Every clause earns its place, though the long emptiness enumeration makes it slightly heavy to parse.

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

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

For a permanent, irreversible mutation with no output schema and one trivial parameter, the description covers permissions, preconditions, required sequencing, and consequences. Nothing an agent needs to call it safely 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?

Only one parameter (session_id) and schema coverage is 100%, so the schema fully documents it. The description adds no parameter-level meaning, which matches the baseline for a fully covered single-param tool.

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

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

States a specific verb (decommission) plus resource (faction mobile base) and a scope qualifier (permanently, empty). It is clearly distinct from siblings like move_faction_mobile_base, jump_faction_mobile_base, or dismantle_outpost.

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

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

Gives rich preconditions: base must be stationary, out of combat, and empty of an enumerated list of contents, with a required ordering step (dismantle facilities and offices first). It does not name sibling alternatives (e.g., move or jump the base instead, or dismantle_outpost for outposts), so routing guidance is implied rather than explicit.

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

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

The description asserts a permanent, destructive, irreversible write ('Permanently delete', 'Cannot be undone'), while the annotations declare readOnlyHint=true and idempotentHint=true. This is a direct contradiction of the structured safety profile, which would badly mislead an agent deciding whether the call is safe.

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 sentence is short and front-loaded, but the parenthetical restates the same fact ('Permanently destroys a note you own') already conveyed by the lead clause, consuming space without adding 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 two-parameter delete tool with no output schema, it covers permanence and the docking prerequisite, which is the core context. However, it omits error behavior, ownership failure modes, and confirmation semantics, and it is undercut by the conflicting readOnlyHint=true annotation.

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 note_id and session_id are already fully documented in the schema (including the permanence warning). The description adds no syntax or format information beyond what the schema provides, 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 states a specific verb and resource ('Permanently delete a note document you own'), which distinguishes it cleanly from siblings such as create_note, write_note, read_note and get_notes. An agent can identify the operation and its target without opening either schema.

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 discloses a precondition ('Requires docking') but never names an alternative or states when-not to use it versus write_note/read_note. Usage context is implied rather than routed, which is only minimally adequate.

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 sparse annotation (readOnlyHint: false), the description discloses that deployment consumes bandwidth, that all:true skips drones exceeding remaining bandwidth, and that the drone must be in the bay. This gives the agent meaningful behavioral expectations without contradicting the annotation.

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

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

The description packs prerequisites, bandwidth cost, related tools, and the all parameter behavior into one dense but efficient sentence. It is front-loaded with the core purpose and avoids filler, though the parenthetical chain could be restructured for easier scanning.

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

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

For a simple deploy action, the description covers the main operational facts: prerequisite state, resource cost, all-mode behavior, and related tools. It does not describe the response or error cases, but this is a lightweight action with no output schema, so the coverage 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?

Schema coverage is 100%, so the baseline is 3. The description adds a little extra by explaining the all:true behavior, but the schema already describes both all and drone_id clearly. The description does not materially enrich 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 names a specific verb ('Deploy'), a resource ('a drone'), and the transition ('from your bay into space'), which clearly distinguishes it from related siblings like load_drone, unload_drone, recall_drone, and upload_drone_script. It also states the core constraint that the drone must already be loaded.

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 usage context: the drone must be loaded, get_drones lists the bay, and upload_drone_script is the follow-up after deployment. It does not explicitly say 'do not use this when X' or name direct alternatives, but the prerequisite and post-requisite guidance effectively situates the tool in the drone lifecycle.

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?

Annotations only declare readOnlyHint=false, so the description carries the real burden and delivers: failure mode (dismantle refused if storage isn't emptied so nothing is lost), no founding-fee refund, cargo-space requirement, and the post-condition that you're set adrift at the POI. This is far beyond what the single annotation conveys.

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 core action is front-loaded in the first clause, followed by prerequisites and consequences in a logical order. It is dense with parentheticals and restates the docking condition twice, so it is slightly heavier than strictly necessary, but nearly every sentence earns its place.

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

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

For a mutation tool with no output schema and only one param, the description covers prerequisites, failure behavior, side effects, and post-conditions thoroughly. An agent has everything needed to decide 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?

One parameter (session_id) with 100% schema description coverage, so the schema already documents it fully. The description adds no param-specific detail, which is acceptable given the baseline of 3 when 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?

Specific verb (dismantle) plus resource (a faction outpost you're docked at) plus the concrete outcome (packed into an Outpost Kit returned to cargo). It is clearly distinguishable from siblings like build_outpost, decommission_faction_mobile_base, and faction_dismantle, which it explicitly routes to for ranches.

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

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

Explicit preconditions and exclusions: must be docked at one of your faction's outposts, not a full station; requires ManageBases permission; storage must be emptied first; a ranch must be dismantled first with faction_dismantle; in-progress facility dismantling must finish. This is a clear when/when-not with a named alternative.

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

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

With only readOnlyHint=false as annotation coverage, the description carries the full behavioral burden and does so richly: it explains that nobody is pre-assigned, that the response carries a mission_id, that the first pilot calling accept_mission claims it 'docked or not', the expiry/cooldown rules, and the special hidden-POI broadcast behavior. This is unusually complete.

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

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

Well front-loaded with the core action first and constraints after, but there is notable duplication between the opening clause and the parenthetical 'Broadcasts an emergency signal to nearby players...', which restates the same idea and slightly bloats the 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?

No output schema exists, so the description appropriately discloses the return contract (mission_id, poi_name and its 'uncharted location' value from hidden POIs). Combined with the usage rules, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so both parameters (session_id, distress_type) are already documented in the schema, and the description's restatement of the fuel/repair/combat meanings duplicates the enum descriptions. No additional syntax or format value is added 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?

States a specific verb ('broadcast') and resource ('distress signal') plus the audience and intent ('to nearby players for emergency rescue'). It is clearly distinguishable from the sibling accept_mission, which is explicitly named as the counterpart action.

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

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

Gives explicit conditions and constraints: cannot be used while docked, only one active signal at a time, 3-hour mission expiry, and a 1-hour cooldown. It also routes the agent to accept_mission to complete the rescue loop.

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 annotations declare readOnlyHint=true and idempotentHint=true, but the description documents irreversible writes: dismantle packages the facility and takes it offline, credits are not refunded, buy_listing purchases, transfer moves items, repair consumes 30% materials. An agent trusting the annotation would treat a destructive multi-action tool as a safe read, which is the exact failure mode the contradiction rule targets.

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?

It is front-loaded with the action list and organized under uppercase headers (WILDLIFE RANCH, DISMANTLE, FACTION SHIP GARAGE, REPAIR), which makes a very long block scannable. However, for a single tool it runs several hundred words and spends substantial space on one subsystem (ranches, packages) while leaving most actions with one-line mentions, so length is not evenly earned.

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 31-action, 34-parameter tool with no output schema, the description covers the high-risk paths (dismantle, ranch, repair, garage) well and points to action 'help' for exhaustive docs. It still leaves many actions undocumented in prose (transfer, buy_listing/cancel_listing, personal_build/personal_visit, job_list/job_reorder, set_output_price), relying on the enum and the help fallback.

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% across 34 parameters, so the baseline is 3; the schema already explains facility_id, species, cull_target, package_ids, deliver_to and the rest. The description adds workflow-level semantics (passing package_ids straight to build/upgrade, one cargo_container cost per package, cull_target behavior) but not per-parameter syntax beyond what the schema already carries.

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+scope: 'Manage facilities at stations (production, faction, personal, sales, and more)' and enumerates all 31 actions. An agent can tell this is the facility-management tool for built structures. It does not explicitly contrast itself with nearby siblings (build_outpost, dismantle_outpost, build_base), so it stops short of a 5.

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

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

Strong conditional routing inside the tool: dismantle vs dismantle_outpost ('Outpost built-in storage and fuel require dismantle_outpost'), 'owned'/'faction_owned' for cross-station views, repair's purpose, and the ranch prerequisites (faction_build + facility_type=wildlife_corral + species, needing Xenobiology and a live population). It never states globally when to reach for this tool versus other structure tools, and most individual actions get no when-to-use 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?

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.