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

Annotations already cover the read-only/idempotent safety profile, and the description reinforces this as a 'stateless read-only' call while adding genuinely new behavior: 32 KB edge limit, 60 RPM rate cap, '?demo=true' bypass, L402 payment (150 sats), and HTTP 400 error behavior. These operational constraints go well beyond the annotations.

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

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

Front-loads the purpose and alternative-routing before the operational details, and every clause carries information. It is dense but appropriately sized; minor compression of the auth/limit details would tighten it further.

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 an output schema present, return values need not be explained, and the description covers trigger, alternative, auth, limits, and error behavior. The only gap is the conflicting default value for time_window, which introduces confusion rather than 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%, so the baseline would be 3, but the description states 'time_window' defaults to '1h' while the schema explicitly says it 'defaults to 24h when omitted'. This direct conflict actively misleads the agent about the parameter's behavior, lowering the score below 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?

States a specific verb and resource ('Analyzes on-chain EVE Frontier killmail.move events in a solar system') plus the concrete outputs ('gatecamp ambush probability' and 'dominant hostile hull doctrines'). This is clearly distinguishable from the sibling prioritize_eve_turret_targets, which it names 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?

Gives an explicit trigger ('assessing solar system PvP danger before jumping a hauler or fleet') and explicitly routes the agent to an alternative ('for computing real-time weapon target-lock priorities... use prioritize_eve_turret_targets instead'). Both when-to-use and when-to-use-something-else are 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), yet the description adds genuinely new operational context: a 32 KB response cap, a 60 RPM rate limit, statelessness, demo-mode support, an L402 payment path (80 sats), and HTTP 400 on invalid input. This is exactly the beyond-annotation detail an agent needs to call the tool without surprises.

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

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

Three tight sentences in a deliberate order: purpose, then routing guidance, then operational constraints. Nothing is padding, though the final sentence packs several distinct facts (limit, rate, query flag, auth, error code) densely enough that it reads more like a config line than prose.

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 only two parameters, an output schema present, and annotations covering safety, the description's remaining burden is operational constraints and routing — both delivered. Nothing an agent needs in order to invoke this 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 and the schema already documents tribe_id and the standing_filter enum plus its default. The description goes slightly beyond that by surfacing a '?demo=true' query flag that does not appear in the input schema, giving the agent an extra invocation mode.

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 ('Audits') and concrete resources (diplomatic standings, friendly/hostile reputation scores, pilot override entries) scoped 'across solar systems'. It explicitly names the sibling it must not be confused with (compile_eve_gate_acl), so an agent can separate auditing from bytecode compilation 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 states the trigger conditions ('Use when checking diplomatic relations or detecting conflicting friendly-fire rules across tribe registries') and names the alternative tool plus the condition that selects it ('for compiling those standings into executable Sui Move Smart Gate ACL bytecode, use compile_eve_gate_acl instead'). Both when-to-use and the exclusion are 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?

Annotations cover the safety profile (readOnly/idempotent/non-destructive), and the description goes well beyond them with operational constraints an agent must know: stateless edge call, 32 KB max payload, 60 RPM rate limit, demo=true or L402 (130 sats) payment path, and an HTTP 400 failure mode for invalid input.

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 in the first sentence and every subsequent clause carries a fact (sibling routing, size limit, rate limit, auth, error code) — nothing is decorative. It loses a point only because the back half is a single semicolon-chained run-on that would read better as separate 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?

Output schema exists, so return values need no explanation, and the description still supplies the operational envelope (stateless, size cap, rate limit, payment/auth paths, error behavior) that an agent needs to invoke this edge compiler correctly. Nothing material is missing for a 2-parameter, no-nesting tool.

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

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

Schema description coverage is 100% with only two parameters, so the schema already carries the semantics and a baseline of 3 applies. The description restates the accepted 'gate_assembly_id' and the 'standing_tiered' toll_mode default, which duplicates what the schema's own enum description says rather than adding new meaning.

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

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

Specific verb ('Compiles') plus a concrete resource triple (Tribe ACLs, diplomatic standings, toll rules) and an explicit output artifact (Sui Move Smart Gate AccessPolicy constraints). It also names the nearest sibling, plan_eve_gate_route, so an agent can separate compilation from route planning 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?

Explicitly states when to use it ('when configuring on-chain jump permissions and LUX/SUI toll schedules for a player-owned Smart Gate') and routes the contrasting case ('for calculating optimal multi-system jump routes ... use plan_eve_gate_route instead'). Both the trigger and the alternative are named, leaving no inference required.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds real operational context: max 32 KB payload, 60 RPM limit, demo mode vs L402 payment (140 sats), and HTTP 400 on invalid input. None of this is derivable from the annotations or schema.

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?

One dense paragraph but front-loaded with the purpose and the sibling routing before operational details; every clause (rate limit, payment, error code) carries information. Slightly overloaded, but no filler 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?

Output schema exists, so return values need no explanation, and auth/payment, limits, and error behavior are all disclosed for a stateless edge endpoint. The only gap is the default-value conflict for 'hull_cargo_class', which undermines correct invocation.

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

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

Schema coverage is 100%, so baseline would be 3, but the description contradicts the schema: it says 'hull_cargo_class' defaults to 'light_courier' while the schema says it 'defaults to medium_hauler when omitted'. That conflict can cause an agent to assume the wrong cargo class when omitting the parameter.

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

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

States a concrete verb and resource ('Scans SSU bid/ask spreads across star systems ... to rank net-profitable arbitrage loops') and explicitly names the sibling it is not ('quote_eve_ssu_market') for the market-maker case. An agent can distinguish it from the 13 siblings without opening a 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 the positive condition ('Use when planning multi-system trade runs to maximize net LUX profit per gigajoule of fuel burned') and an explicit exclusion routing to 'quote_eve_ssu_market' for internal SSU quoting. When-to-use, when-not, and the alternative are all 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?

Annotations already declare read-only, idempotent, non-destructive, closed-world, but the description adds substantial operational context beyond them: stateless edge call, 32 KB size cap, 60 RPM rate limit, ?demo=true or L402 payment (200 sats), and HTTP 400 error behavior on invalid input.

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, then routing guidance, then operational constraints. Dense with details but every sentence earns its place; only minor tightness could be improved.

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 an output schema present, return values need not be explained, and annotations already cover the safety profile. The description fills remaining gaps (limits, auth, error codes) and routes to the right sibling, so an agent has everything needed to call it correctly.

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

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

Schema coverage is 100%, so the schema carries parameter documentation and the baseline is 3. The description names both params and the assembly_id default, but the stated default ('standard') conflicts with the schema's documented default ('frontier-assembly-01'), which adds risk rather than value.

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

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

States a specific compound verb (generates and statically audits) and resource (Sui Move smart contract modules for EVE Frontier Smart Assemblies) with named patterns. It clearly differentiates itself from the sibling simulate_eve_sui_ptb by naming it explicitly.

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 (authoring custom Sui Move extensions for Smart Gates, Smart Turrets, or Smart Storage Units) and an explicit alternative with its selecting condition (simulate_eve_sui_ptb for pre-signed PTB command arrays). 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?

Annotations already declare readOnly/idempotent/non-destructive/closed-world, and the description goes well beyond them: stateless edge call, 32 KB payload cap, 60 RPM rate limit, demo-mode or L402 payment (80 sats), and an HTTP 400 failure mode. These are operational traits an agent cannot recover from the annotations or schema.

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-loaded with purpose then routing, then operational constraints. The second sentence is dense and slightly run-on (limits, params, payment, error code chained together), which costs a point, but no clause is 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?

An output schema exists so return values need no explanation; the description covers purpose, sibling routing, safety profile, rate/size limits, payment modes, and the error path. For a 2-param read tool this is complete.

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

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

Schema coverage is 100%, so the baseline is 3; the description still adds invocation semantics the schema lacks, notably the '?demo=true' switch and the L402 paid path, plus the 400-on-invalid contract. The assembly_class default it repeats is already in the schema, so it falls short of a 5.

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

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

States a specific verb ('Inspects') and a precisely enumerated resource: on-chain object metadata, owner capability ID, online power status, and attached Sui Move package digest. It explicitly separates itself from the source-generation sibling (generate_eve_assembly_move), so an agent can pick it 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?

Gives an explicit when-to-use ('verifying whether a Smart Turret, Smart Gate, or Smart Storage Unit is online and checking its bound Move module before interacting') and an explicit when-not with the named alternative ('for generating or auditing custom Sui Move assembly source code, use generate_eve_assembly_move instead'). 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description goes well beyond that: stateless edge call, 32 KB payload cap, 60 RPM throttle, access modes ('?demo=true' or L402 at 140 sats), and failure behavior (HTTP 400 on invalid input). These are exactly the operational constraints an agent needs to avoid a failed or throttled call.

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 the routing rule to the sibling tool are front-loaded in the first clause, and the operational constraints are packed into one dense final sentence. Nothing is wasted, though the trailing sentence carries a lot of comma-separated clauses that could be split for readability.

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

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

An output schema exists, so return values need not be described, and the description still covers access modes, rate limits, error codes, and scoping. The one real gap is the incorrect default for 'alert_threshold_hours', which is a completeness defect rather than a missing topic.

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 self-documented, so the baseline would be 3, but the description states 'alert_threshold_hours' defaults to '24h' while the schema says it defaults to '36h' when omitted. Repeating a parameter with a conflicting default actively misleads the agent about an omitted-argument call.

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

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

States a specific verb and resource ('Monitors constellation-wide Lagrange Network Node fuel reserves') and enumerates the three concrete outputs: weakest node identification, convoy urgency calculation, and constellation-wide health. It explicitly contrasts itself with the sibling optimize_eve_node_power, so an agent can route between them 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?

Gives an explicit when-to-use ('auditing multi-system sovereignty fuel health across an entire tribe constellation') and an explicit when-not-to-use with the named alternative ('for optimizing gigajoule load on a single individual Lagrange Network Node, use optimize_eve_node_power instead'). The scope boundary between fleet-wide audit and single-node tuning is unambiguous.

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

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

Annotations already declare readOnly/idempotent/non-destructive, yet the description adds substantial context they do not carry: stateless edge call, 32 KB payload cap, 60 RPM rate limit, auth via '?demo=true' or L402 (100 sats), and HTTP 400 on invalid input. These are exactly the operational traits an agent needs before invoking.

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 the sibling routing come first, followed by operational constraints in a compact single-sentence block. It is dense but front-loaded and wastes little; only the parenthetical constraint run borders on over-packing.

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?

An output schema exists, so return values need no explanation, and the description covers purpose, alternative routing, auth, limits, and error behavior. Nothing material for a correct call 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%, so both parameters (including the enum values and the 'balanced' default) are already documented. The description restates node_id and the operating_profile default without adding format, constraint, or edge-case meaning beyond the schema, which lands at the 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 (calculates) plus the exact resource and outputs: hourly GJ fuel burn, capacity headroom, offline vulnerability windows for connected Smart Assemblies. It also explicitly distinguishes itself from simulate_eve_capacitor_siege, so an agent can route 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?

Gives a positive use case ('balancing steady-state power allocations on a single Lagrange Network Node') and names the alternative tool with the condition that selects it ('stress-testing node capacitor depletion under active hostile fleet bombardment'). When-to-use and when-not-to-use are both 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds substantial context beyond them: statelessness, a 32 KB size cap, a 60 RPM rate limit, L402/demo auth options, and HTTP 400 on invalid input. This is exactly the operational detail an agent needs before invoking.

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 purpose, then usage, then behavioral constraints in a tight, dense block with little waste. The trailing parenthetical about defaults is somewhat cramped, but the ordering is effective.

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 an output schema present, return values need no explanation, and the description covers purpose, routing, auth, limits and errors. The only blemish is the 'destination_system defaults to standard' note that conflicts with the required-field schema.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents all three parameters including the enum. The description adds only marginal notes about origin/destination and a questionable claim that 'destination_system defaults to standard' when the schema marks it required.

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

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

States a specific verb ('Calculates optimal stargate jump routes') with a precise resource and scope, plus the optimization dimensions (fuel, tolls, jump count). It is immediately distinguishable from the sibling find_eve_ssu_arbitrage, which it names explicitly.

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 an explicit when-to-use ('plotting a ship transit path across public and tribe-restricted Smart Gates') and a when-not-to-use with a named alternative ('for ... commodity arbitrage trade loops ... use find_eve_ssu_arbitrage instead'). 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?

Annotations already cover read-only, idempotent, and non-destructive safety, but the description adds operational behavior: stateless edge call, 32 KB and 60 RPM limits, demo or L402 payment support, and HTTP 400 on invalid input. These details materially help correct invocation and do not contradict annotations.

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

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

Three sentences, with purpose and sibling routing front-loaded before operational constraints. The final sentence is dense but every detail—size, rate limit, auth, error behavior—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?

An output schema exists and annotations cover safety semantics, yet the description still supplies the missing operational context around auth, limits, demo mode, and invalid-input behavior. Enough information is present to call the tool correctly.

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

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

Schema coverage is 100%, with clear descriptions for both turret_id and engagement_doctrine. The description restates turret_id and the default doctrine, adding only minor context beyond the schema, so baseline 3 is appropriate.

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

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

Names a concrete verb ('Evaluates radar contacts') and specific outputs ('target-lock priorities and fire authorizations'), and explicitly distinguishes it from analyze_eve_killmail_threats. The agent can identify the tool's role 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?

States exactly when to use it: ranking active grid radar contacts for automated Smart Turret engagement. It also routes historical killmail and ambush review to the named sibling tool, giving an explicit alternative condition.

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, idempotentHint, and destructiveHint=false, but the description adds substantial context beyond them: it specifies a stateless read-only edge call with max 32 KB payload, 60 RPM rate limit, support for '?demo=true' or L402 (120 sats), and HTTP 400 on invalid input. These details are useful for an agent to know about cost, rate limits, and error handling. It does not describe the return format, but an output schema exists, so a 4 is appropriate.

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 three tightly packed sentences with zero waste: the first states what the tool does, the second gives usage guidance and alternatives, and the third covers behavioral details like rate limits, payment, and error behavior. It is front-loaded and every sentence earns its place.

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

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

Given the tool's complexity (a paid edge call with rate limits and authentication), the description provides enough context for an agent to call it correctly: it covers purpose, usage, alternatives, rate/size limits, payment options, and error behavior. Annotations and output schema fill in the safety and return-value details, so nothing critical 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%, so the schema already fully documents both parameters. The description only restates that 'resource_type' is accepted and that 'pricing_regime' defaults to 'inventory_balanced', which is already in the schema. It adds no meaning 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 ('Computes') and resource ('dynamic bonding-curve bid/ask quotes in LUX and per-transaction anti-drain caps') for a clearly identified target ('player-owned Smart Storage Unit (SSU)'). It also explicitly distinguishes itself from the sibling tool find_eve_ssu_arbitrage, so an agent can tell them apart 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?

The description provides explicit when-to-use guidance: 'Use when setting automated market-maker buy/sell prices for a single SSU vending inventory.' It also names the alternative tool and the condition that selects it: 'for scanning multiple SSUs across star systems to find profitable trade routes, use find_eve_ssu_arbitrage instead.' 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?

Annotations already cover read-only/idempotent/non-destructive, and the description adds genuinely new operational context: statelessness, a 32 KB payload cap, a 60 RPM rate limit, demo mode, L402 payment cost (135 sats), and HTTP 400 on invalid input.

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 front-loaded paragraph that leads with the simulation purpose and alternative routing; the trailing constraints are dense and parenthetical but each clause carries usable 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?

Covers auth, rate limits, payload limits, error behavior and usage context, and an output schema exists so return values need not be described. The one real gap is the internal inconsistency about the siege_intensity default, which undercuts completeness for a 2-param tool.

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

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

Schema coverage is 100%, so the schema normally carries parameter semantics, but the description actively states 'siege_intensity' defaults to 'skirmish_frigate_squad' while the schema says it defaults to 'heavy_cruiser_wing'. That conflict is misleading rather than additive, so it falls below the 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 and resource (simulates Lagrange node capacitor drain under siege and computes load-shedding order) and explicitly distinguishes itself from the sibling optimize_eve_node_power. An agent can select it 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?

Gives an explicit when-to-use ('preparing base defense power-shedding schedules against an incoming hostile fleet') and names the alternative with the condition that selects it ('routine peacetime fuel burn ... use optimize_eve_node_power instead'). 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description goes well beyond them: stateless edge call, 32 KB payload cap, 60 RPM rate limit, '?demo=true' or L402 payment (150 sats), and an HTTP 400 failure mode. These operational constraints are exactly the context an agent needs before invoking.

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, then routing, then operational constraints; every clause carries information. The final sentence is dense and run-on, packing four constraints together, which slightly hurts scanability.

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?

An output schema exists so return values need not be described, annotations cover the safety profile, and the description fills the remaining gaps (size, rate, auth/payment, error behavior, statelessness). An agent has everything needed to call it correctly.

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

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

Schema coverage is 100% and both parameters are fully documented there, so the baseline is 3. The description's mentions of 'ptb_commands_json' and the 'strict_zero_drain' default largely restate the schema rather than adding format or edge-case detail.

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

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

States a specific verb (simulates) plus the resource (Sui PTB command sequences) and the concrete hazards it detects (unauthorized coin splits, object transfers, unconsumed HotPotato receipts). It also names the sibling it is not (verify_eve_zklogin_character), so an agent can route without opening 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?

Gives an explicit trigger ('Use when auditing an untrusted EVE Frontier transaction bundle before signing with a pilot wallet') and an explicit alternative with its own condition ('for verifying pilot zkLogin JWT proofs ... use verify_eve_zklogin_character instead'). Both when-to-use and when-to-use-something-else are covered.

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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds substantial context beyond them: stateless execution, a 32 KB payload cap, a 60 RPM rate limit, L402 payment (100 sats) and demo-mode access, and the failure mode (HTTP 400 on invalid proof). That is exactly the operationally relevant detail 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-loaded with purpose before usage and technical constraints, and every sentence carries information. It loses a point only because the parenthetical restatement of 'jwt_proof' and the 'ephemeral_scheme' default duplicates the schema rather than adding new meaning.

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?

An output schema exists, so return values needn't be described, and the description still covers auth context, rate/size limits, payment gating, and error behavior for a mutation-free verification call. Nothing an agent needs to invoke 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%, so both parameters (jwt_proof, ephemeral_scheme) are already fully documented including the enum values and default. The description restates the default and the jwt_proof name but adds no syntax or format detail beyond the schema, which is the baseline-3 case.

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 (verifies) and precise resources (zkLogin BN254 proofs, ephemeral session signatures, SmartCharacter ownership). It explicitly names the sibling audit_eve_tribe_standings as the wrong tool for the adjacent task, so an agent can distinguish it without opening 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?

Gives explicit when-to-use ('authenticating a pilot's off-chain OAuth/zkLogin session before granting tribe vault or dApp access') plus a when-not/alternative routing clause pointing to audit_eve_tribe_standings. 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.