Diogenes EVE: Frontier Sui Move MCP

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

Beyond the read-only annotations, it discloses stateless edge-call behavior, a 32 KB maximum, a 60 RPM rate limit, demo/L402 access with a 30 sats cost, and HTTP 400 on invalid input. These are operationally meaningful constraints not present in the structured 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 front-loaded with the purpose and usage guidance, then adds access and constraint details. It is dense but efficient overall, though the incorrect time_window default reduces the value of one packed detail.

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

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

With an output schema present, the description does not need to explain return values, and it covers usage, access, rate limits, and error behavior well. However, the contradictory time_window default means the definition is not fully internally consistent.

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 already documents both parameters. The description adds a default for time_window, but it says the default is '1h' while the schema says '24h', creating a harmful contradiction rather than useful clarification.

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?

It states a specific verb and resource: analyzing on-chain EVE Frontier killmail.move events to quantify gatecamp ambush probability and identify hostile hull doctrines. This is clearly distinguishable from sibling tools such as prioritize_eve_turret_targets.

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

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

The description explicitly says when to use it: assessing solar-system PvP danger before jumping a hauler or fleet. It also names an alternative tool and the condition selecting that alternative: real-time weapon target-lock priorities during active grid combat.

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 establish read-only, idempotent, non-destructive behavior, and the description adds operational details beyond that: stateless edge call, 32 KB limit, 60 RPM, demo/L402 access, and HTTP 400 on invalid input. These are exactly the behavioral constraints an agent needs before invoking the tool.

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

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

The description is front-loaded with purpose, then usage, then operational constraints. Each sentence contributes necessary information, and there is no redundant restatement of the tool name or title.

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 fully documented parameters, an output schema, and annotations covering safety profile, the description is complete enough for correct invocation. It covers use cases, alternatives, rate/size limits, payment/demo access, and error behavior.

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

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

Schema description coverage is 100%, so the schema already documents tribe_id and the standing_filter enum. The description only repeats the default value for standing_filter and adds no further parameter semantics beyond the structured 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 opens with a specific verb and resource: auditing EVE Frontier Tribe diplomatic standings, reputation scores, and pilot override entries. It clearly distinguishes this read/audit tool from the sibling that compiles standings into Sui Move ACL bytecode.

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 when to use the tool: checking diplomatic relations or detecting conflicting friendly-fire rules. It also names the alternative compile_eve_gate_acl for the adjacent compilation task, which gives the agent a clear routing decision.

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 mode vs L402 (30 sats) payment, and HTTP 400 on invalid input. These are exactly the operational traits an agent needs to avoid failed or throttled calls.

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 usage, then operational constraints — a sensible ordering with no filler sentences. The final clause packs several constraints (size, rate, auth, error code) into one long sentence, which is dense but each element is load-bearing.

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 described, and the description still covers everything else an agent needs: statelessness, size limit, rate limit, authentication options, and error behavior. For a two-parameter compiler call 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%, with the enum and defaults already documented, so the schema carries the semantic load. The description only restates the 'toll_mode' default ('standing_tiered') and that 'gate_assembly_id' is accepted, adding no new meaning such as identifier format or how toll_mode interacts with standings. 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 ('Compiles') plus three concrete resources (Tribe ACLs, diplomatic standings, surge-pricing toll rules) and names the exact output artifact (Sui Move Smart Gate AccessPolicy constraints). It explicitly distinguishes itself from the nearest sibling, plan_eve_gate_route, so an agent can select 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 clause ('configuring on-chain jump permissions and LUX/SUI toll schedules for a player-owned Smart Gate') and an explicit when-not/alternative clause routing route-planning queries to plan_eve_gate_route. Both the positive and negative selection conditions are 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?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds operational context those hints cannot: stateless edge call, 32 KB payload cap, 60 RPM limit, demo flag or L402 payment of 30 sats, and HTTP 400 on invalid input. That is exactly the kind of auth, throttling and failure-mode detail an agent needs before invoking a paid endpoint.

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?

Dense but front-loaded: purpose and routing to the alternative come first, operational constraints are packed into a final clause. The auth/rate-limit sentence is compressed almost to shorthand, which borders on cryptic, but no sentence 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 ranking/loop return details need not be explained; the description instead covers what the schema cannot — cost model, limits, payment, error behavior. The only real completeness defect is the incorrect default for hull_cargo_class, which contradicts the parameter definition.

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

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

Schema coverage is 100% and the description restates the origin_system and hull_cargo_class roles, so it adds little beyond the schema. Worse, it says hull_cargo_class 'defaults to light_courier' while the schema says the default is 'medium_hauler' — a direct conflict that could make an agent mis-model cargo volume and fuel cost.

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: scanning SSU bid/ask spreads across star systems against cargo capacity and fuel costs to rank net-profitable arbitrage loops. It explicitly names the sibling it is not (quote_eve_ssu_market) and the condition that separates them, so an agent can choose 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 use case ('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 market-maker quotes. When-to-use and when-not-to-use are both 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, closed-world), and the description adds substantial non-structured behavior: statelessness, a 32 KB payload cap, a 60 RPM rate limit, an L402 payment path (45 sats) versus '?demo=true', and an HTTP 400 failure mode for invalid input. Those are operational details an agent cannot recover from the schema or 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-loaded with purpose, then usage/alternative, then operational constraints — a sensible ordering. The final sentence is densely packed with semicolon-separated clauses (size cap, rate limit, demo flag, L402 price, error code) that read as one run-on, but no sentence 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-value detail is legitimately omitted, and the description covers payment, limits, and failure behavior. What is left slightly unclear is whether the static audit findings are part of that output or a separate concern, and the conflicting default noted above leaves one open question at call time.

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 actively adds contradictory information: it says 'assembly_id' defaults to 'standard' while the schema documents the default as 'frontier-assembly-01'. It also never mentions the 'fuel_distributor' enum value that the tool accepts. Conflicting parameter guidance is worse than none.

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+resource: 'Generates and statically audits Sui Move smart contract modules for EVE Frontier Smart Assemblies', and names the design patterns (Witness, Capability, HotPotato) that define the output shape. It also distinguishes itself from the sibling simulate_eve_sui_ptb by resource scope, 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?

Explicit when-to-use ('Use when authoring custom Sui Move extensions for Smart Gates, Smart Turrets, or Smart Storage Units') plus an explicit alternative and its selecting condition ('for simulating pre-signed ... PTB command arrays before wallet execution, use simulate_eve_sui_ptb instead'). This is the rare case where sibling routing is spelled out rather than inferred.

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 still adds materially new behavior: stateless edge call, 32 KB payload cap, 60 RPM rate limit, demo=true or L402 payment of 20 sats, and an HTTP 400 failure mode. These are operational facts an agent cannot get from the 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 order is well front-loaded: purpose, then when-to-use and alternative, then transport constraints. The final sentence is a dense run-on that bundles limits, auth options, and error behavior together, which costs a little readability but wastes no 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?

With only two well-documented parameters, full annotation coverage, and an output schema handling return values, the remaining burden is transport and cost behavior, which the description covers (rate limit, size cap, L402/demo auth, 400 on invalid). Nothing an agent needs to call this 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 already document format and the enum of assembly classes. The description only restates the 'smart_gate' default that the schema already specifies, adding no new syntax or validation semantics; baseline 3 applies when the schema does the heavy lifting.

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 ('Inspects') and enumerates exactly what state is read: on-chain object metadata, owner capability ID, online power status, and bound Sui Move package digest. It also explicitly distinguishes itself from generate_eve_assembly_move, so an agent can tell the two 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?

It states the use case positively ('verifying whether a Smart Turret, Smart Gate, or Smart Storage Unit is online and checking its bound Move module before interacting') and names the alternative with its condition ('for generating or auditing custom Sui Move assembly source code, use generate_eve_assembly_move instead'). Both when-to-use and when-not-to-use 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 already declare readOnly/idempotent/non-destructive, but the description goes well beyond them: stateless edge call, 32 KB response ceiling, 60 RPM rate limit, demo mode, L402 payment of 30 sats, and HTTP 400 on invalid input. Those are exactly the operational constraints 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 what the tool does, then the alternative, then operational constraints. Dense but each clause carries information; the parenthetical list of operational facts is slightly compressed but not wasteful.

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

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

Output schema exists and annotations cover the safety profile, and the description supplies rate limits, auth options, and error behavior. The only material gap is the inconsistent default for alert_threshold_hours, which leaves the agent unsure which value applies.

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 states alert_threshold_hours 'defaults to 24h' while the schema description says it defaults to '36h' when omitted. That direct conflict actively misleads on parameter behavior rather than adding meaning, so it drops 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 (monitors) plus the exact resource (constellation-wide Lagrange Network Node fuel reserves) and two derived outputs: weakest node and convoy resupply urgency. It explicitly contrasts itself with optimize_eve_node_power, so an agent can distinguish multi-node from single-node scope 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?

Names the selecting condition ('auditing multi-system sovereignty fuel health across an entire tribe constellation') and routes the alternative case to optimize_eve_node_power by name. 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 declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, and the description adds meaningful operational context beyond them. It discloses stateless edge-call behavior, request-size and rate limits, demo/L402 payment access, and invalid-input HTTP 400 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 three tight sentences with no wasted language. Purpose, alternative-tool routing, and operational constraints are front-loaded in that order.

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 rich annotations, full schema coverage, and presence of an output schema, the description provides everything needed to select and invoke the tool. It covers scope, alternative, limits, payment/demo access, and error behavior without needing to explain 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?

Schema description coverage is 100%, so the schema already documents both parameters. The description repeats the node_id input and operating_profile default but adds little semantic detail beyond what the schema and enum already provide, making 3 the appropriate 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 states a specific verb and resource: it calculates Lagrange Network Node hourly GJ fuel burn rates, capacity headroom, and offline vulnerability windows. It also explicitly distinguishes the tool from simulate_eve_capacitor_siege, so an agent can identify its 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?

It gives an explicit when-to-use condition: balancing steady-state power allocations on a single Lagrange Network Node. It also names the alternative tool and the condition for choosing it: stress-testing capacitor depletion under hostile fleet bombardment should use simulate_eve_capacitor_siege instead.

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 behavior, and the description adds substantial context beyond them: stateless edge call, 32 KB max, 60 RPM, demo/L402 payment option, and HTTP 400 on invalid input. No annotation contradiction is present.

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 with purpose and usage before operational details, and most sentences carry useful information. It is dense, and the parenthetical destination_system default adds avoidable confusion.

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 stateless routing tool with an output schema and full annotation coverage, the description supplies the key operational constraints an agent needs: auth/payment options, rate limit, payload limit, and invalid-input 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%, so the schema already documents the parameters. However, the description says destination_system defaults to 'standard', while the schema marks destination_system as required and gives no default, which is misleading parameter guidance.

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: calculating optimal stargate jump routes between EVE Frontier solar systems. It also names the optimization goals (fuel, tolls, jump count) and explicitly distinguishes itself from the sibling arbitrage 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?

Gives an explicit use case: plotting ship transit across public and tribe-restricted Smart Gates. It also names the alternative tool, find_eve_ssu_arbitrage, and the condition that selects it.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new operational facts: stateless, 32 KB payload cap, 60 RPM, demo mode or L402 payment (25 sats), and HTTP 400 on invalid input. It does not spell out how ties or missing radar data are handled, so it falls just short of fully disclosing 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?

Three sentences, front-loaded with purpose then alternative then operational constraints; no filler. The final sentence is dense, packing auth, limits, and error behavior 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?

Output schema exists, so return values need no explanation; the description still covers invocation prerequisites (demo/L402 auth), rate and size limits, and failure mode. Nothing an agent needs to call this 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 coverage is 100%, so both parameters are already documented, including the enum values and the 'highest_threat' default. The description only restates the doctrine default and the turret_id requirement, adding no syntax or weighting 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?

States a specific verb and resource ('Evaluates radar contacts by range, transversal velocity, and Tribe standing') plus the concrete output ('deterministic Smart Turret target-lock priorities and fire authorizations'). It explicitly names the sibling it is not (analyze_eve_killmail_threats), 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 both sides of the decision: 'Use when ranking active grid radar contacts for automated Smart Turret engagement' and 'for reviewing historical solar system killmails ... use analyze_eve_killmail_threats instead.' The alternative tool and the condition selecting it 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 already declare read-only/idempotent/non-destructive, and the description adds substantial context beyond them: stateless edge call, 32 KB cap, 60 RPM limit, ?demo=true vs L402 (25 sats) auth model, and HTTP 400 on invalid input. This is rich operational 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?

A single dense sentence that front-loads the core computation then tacks on routing, limits, auth, and error behavior. Every clause earns its place, though the density is high.

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 needn't be explained; the description still covers auth, rate/size limits, defaults, error behavior, and sibling routing. Nothing an agent needs 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 coverage is 100% and both params are documented in the schema, so baseline is 3. The description restates pricing_regime's default and mentions resource_type, adding little beyond the schema's own enum/default 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?

States a specific verb+resource: computes bonding-curve bid/ask quotes in LUX with anti-drain caps for an SSU. It clearly distinguishes itself from find_eve_ssu_arbitrage by naming it as the multi-SSU alternative.

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 when-to-use ('setting automated market-maker buy/sell prices for a single SSU vending inventory') and when-not-to ('for scanning multiple SSUs... use find_eve_ssu_arbitrage instead'). The condition selecting the sibling 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description goes well beyond them: statelessness, a 32 KB payload ceiling, a 60 RPM rate limit, a ?demo=true preview path, an L402 payment of 30 sats, and an HTTP 400 failure mode for invalid input. These are exactly the operational facts an agent needs before calling a metered edge endpoint.

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 alternatives, then operational constraints; no filler sentences. The third sentence is dense to the point of being a comma-spliced list of transport details, but every clause carries 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?

An output schema exists, so return values need not be described, and the description covers payment, rate limits, demo mode, and error signaling. The one completeness defect is the default-value error, which leaves the agent less certain about the schema than if the description had said nothing at all.

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 actively conflicts with the schema: it says siege_intensity 'defaults to skirmish_frigate_squad' while the schema property description states the default is 'heavy_cruiser_wing'. An agent that trusts the prose will omit the parameter expecting the wrong tier and get a materially wrong simulation. The node_id mention merely restates 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 (simulates/computes), a specific resource (Lagrange Network Node GJ capacitor drain), and the derived output (optimal assembly load-shedding order). It also explicitly distinguishes itself from the nearest sibling, optimize_eve_node_power, 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 both sides of the routing decision: use this when preparing base defense power-shedding schedules against an incoming hostile fleet, and use optimize_eve_node_power for routine peacetime fuel burn and reserve headroom. The trigger condition (hostile siege) and the exclusion (peacetime) 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 declare readOnly, idempotent, non-destructive, closed-world, but the description adds operational behavior the annotations don't: stateless edge call, 32 KB limit, 60 RPM, demo mode or L402 payment (35 sats), and HTTP 400 on invalid input. This is exactly the kind of extra behavioral context 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?

The sentence is dense but front-loads purpose before caveats, and every clause carries useful signal (use case, alternative, limits, auth). It is slightly packed with operational details in one paragraph, keeping it just below a 5.

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

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

An output schema exists, so the description needn't explain return values. Given the two-parameter schema and rich annotations, the definition supplies everything an agent needs to call it correctly: scope, alternative, limits, auth, and 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 description coverage is 100%, so both parameters are already documented. The description restates the default for strictness_mode but adds no syntax or format details beyond the schema's own explanation of ptb_commands_json. Baseline 3 applies when the schema does the heavy lifting.

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') and resource ('Sui Programmable Transaction Block (PTB) command sequences') plus the concrete detections (coin splits, object transfers, unconsumed HotPotato receipts). It explicitly distinguishes itself from verify_eve_zklogin_character, 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 an explicit use case ('auditing an untrusted EVE Frontier transaction bundle before signing with a pilot wallet') and names the alternative tool and its purpose ('for verifying pilot zkLogin JWT proofs and character ownership capabilities, use verify_eve_zklogin_character instead'). Both when-to-use and when-not 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), yet the description still adds real context beyond them: stateless edge call, 32 KB payload cap, 60 RPM rate limit, demo-mode or L402 payment (25 sats), and an HTTP 400 failure mode for invalid proofs. That is exactly the operational 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?

Three sentences, purpose and routing front-loaded, with no filler. It is dense and slightly over-packed (rate limits, L402 pricing, and HTTP status codes in one breath), but each clause carries information an agent could act on.

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 2-parameter read-only verifier with a full output schema and rich annotations, the description covers authentication intent, inputs, limits, and failure behavior. Nothing an agent needs in order 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 coverage is 100% and both parameters carry their own descriptions, so the schema does the heavy lifting. The description restates the 'ephemeral_scheme' default already documented in the schema and adds a non-parameter detail ('?demo=true'), which is mildly useful but not meaningful parameter semantics. 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 ('Verifies') plus three concrete resources: Sui zkLogin BN254 zero-knowledge proofs, ephemeral session signatures, and SmartCharacter ownership capabilities. It also explicitly names the sibling it is not (audit_eve_tribe_standings), 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 an explicit trigger ('Use when authenticating a pilot's off-chain OAuth/zkLogin session before granting tribe vault or dApp access') and an explicit alternative with its condition ('for auditing tribe-wide diplomatic standings... use audit_eve_tribe_standings instead'). Nothing about when-to-use 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.