Guild Wars 1 Build Compiler

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds useful context that the blob format is 'pwnd0001...' and that whitespace/line wraps are tolerated, which is beyond the schema. This helps the agent anticipate input variations without contradicting 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 two sentences long, front-loaded with the primary purpose, and includes the essential alternative in the second sentence. No unnecessary words.

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

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

Given the tool's simplicity, an output schema, and strong annotations, the description provides sufficient context: input format, what the tool does, and when to use an alternative. It doesn't need to explain return values because the output schema exists.

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 the single parameter 'pwnd' with 100% coverage, so the baseline is 3. The description adds practical details beyond the schema by explaining the blob format and whitespace tolerance, which helps the agent understand how to pass the input correctly.

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

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

The description uses a specific verb 'Decode' and clearly identifies the resource ('paw-ned2 team build blob') and the output components (player/hero label, description, skill bars). It distinguishes from the sibling tool decode_template by explicitly calling out the single-build case.

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 this tool (for team build blobs) and provides an alternative: 'For a single (non-team) build code, use decode_template instead.' This gives clear guidance on tool selection.

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

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

Annotations already provide readOnlyHint and idempotentHint. The description adds behavioral details beyond these: it tolerates whitespace and line wraps, and it decodes into specific components (professions, attributes, skills with stats and descriptions). This adds useful context about input flexibility and output structure, though it could mention error handling for invalid codes.

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 purpose with an example, then add usage guidance and sibling differentiation. Every sentence serves a distinct purpose with 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?

Given that an output schema exists (so return values are covered), the description provides sufficient context: the input parameter is fully described, the output scope is clear, and the tool's single-build vs multi-hero distinction is addressed. The sibling list further aids 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% with one parameter described as 'The template code string'. The description adds significant meaning beyond the schema: it provides a concrete example code, implies a max length (128 in schema), and explains that whitespace and line wraps are tolerated. This fully compensates for any lacking details in the schema itself.

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 'Decode an in-game GW1 skill template code' with a concrete example. It specifies the output includes professions, attributes, and 8 skills with stats and descriptions. It also distinguishes itself from the sibling 'decode_pawned_team' by noting it decodes a single build code rather than a multi-hero team blob.

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 tells when to use this tool (for single build codes) and when not (for multi-hero team blobs, use decode_pawned_team). It also notes that whitespace and line wraps are tolerated. However, it does not mention other siblings like encode_template or validate_build as alternatives for different tasks, which would strengthen guidance.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds valuable behavioral details: the build is validated first and errors are returned on rule violations, unknown skill names produce closest-match suggestions, and hand-written codes are invalid in-game. This significantly enhances understanding of the tool's error handling and constraints.

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

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

The description is compact and well-structured: a clear opening sentence defining the core function, a sentence on validation/error behavior, and an IMPORTANT callout about hand-written codes. Every sentence contributes essential information 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 complexity (7 parameters, output schema present), the description covers the essential behavior: input composition, validation, error handling, and relationship to decode_template. It does not need to explain return values since an output schema exists, and it adequately orients the agent on when and how to use the tool.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The description reinforces that skills must be exact English names and mentions 'professions, attributes, 8 skills' but adds little beyond the schema's own descriptions. It does not explain parameter formats or constraints beyond what schema already states.

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: 'Compile a build (professions, attributes, 8 skills by exact English name) into an official in-game template code.' It uses a specific verb ('compile'), identifies the resource ('template code'), and lists the key inputs. This distinguishes it from sibling tools like decode_template, which is explicitly mentioned as the verification counterpart.

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 guidance: template codes MUST come from this tool, never hand-write or guess codes, and if unsure, verify with decode_template. This establishes clear when-to-use and when-not-to-use scenarios, and names the alternative tool for verification.

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 readOnly, idempotent, non-destructive. The description goes beyond by explaining the exact output fields (profession, campaign, unlock method), the ID match with AccountExport, and a crucial niche behavior: heroes cannot equip PvE-only skills, and validate_build flags them as errors. This is rich contextual behavior not visible in 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?

The description is front-loaded with the core action and return value, then progressively adds caveats and alternatives. It is longer than the absolute minimum (5 sentences), but every sentence adds distinct value: the PvE skill restriction and validate_build behavior are important not to miss. The structure is logical, though it could be tightened slightly without losing 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?

The description covers all key aspects: what the tool does, how to invoke it (name/id), what it returns, important gameplay constraints, integration with validate_build, and when to use an alternative tool. An output schema exists, so return structure doesn't need description. For a simple lookup tool, this is exceptionally 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?

Input schema already describes both parameters with 100% coverage, so the baseline is 3. The description adds meaningful context: it clarifies that lookups can be by name or id, and specifies that 'id' is the GWCA HeroID matching the AccountExport plugin output. This extra provenance helps agents convert external IDs correctly. Not a lot more is needed given the schema's clarity.

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 'Look up' with a clear resource 'a GW1 hero' and scopes by 'name or by id'. It explicitly lists what is returned (profession, campaign, unlock), and distinguishes itself from the sibling list_heroes by stating 'Use this for one known hero; to browse or filter the roster, use list_heroes instead.' This leaves no ambiguity about the tool's function.

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 guidance: 'Use this for one known hero' and clearly names the alternative for browsing: 'to browse or filter the roster, use list_heroes instead.' It also includes a critical downstream behavioral note about validate_build, helping the agent decide when this tool is relevant.

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 readOnly and idempotent, and the description adds valuable behavioral context: exact-match requirement, fallback to closest matches for spelling correction, and a clear list of returned stats. This goes beyond the annotations without contradicting them.

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

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

The description is compact and front-loaded, with every sentence carrying distinct information (function, outputs, fallback, usage guidance). No filler or repetition of schema 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 simple read-only lookup tool with an output schema and strong annotations, the description covers all necessary context: what it looks up, what it returns, how it behaves on not-found, and when to use an alternative. There is no significant missing information.

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

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

Schema coverage is 100% with detailed descriptions for both parameters, so the baseline is 3. The description reaffirms 'exact English name' and 'template skill id' but adds no new semantic detail beyond what the schema already 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 clearly states a specific action ('Look up a single GW1 skill') with input methods (exact English name or template skill id) and explicitly differentiates from search_skills for discovery. The verb+resource combination is precise 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 gives explicit when-to-use and when-not-to-use guidance: 'Use this when you already know the exact skill; to discover skills by profession, attribute or name fragment, use search_skills instead.' It names the alternative tool and contrasts the use cases clearly.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by revealing what the output conveys: which professions are coverable and unlocking status. This goes beyond the schema's raw filter parameters.

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, direct and front-loaded with the main action. The second sentence adds practical context without redundancy. 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 filtered list tool with a rich output schema and comprehensive annotations, the description fully covers the purpose, usage context, and key behavioral details. 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%, and the parameters are exhaustively documented with allowed values. The description's mention of filtering by 'profession or campaign' adds no new semantics beyond what the schema already provides, so a baseline 3 is appropriate.

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

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

The description states a specific action: 'List all GW1 heroes', with optional filters by profession or campaign. This clearly distinguishes it from siblings like get_hero (which fetches a single hero) and search_skills (different resource).

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

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

It explains a concrete use case: 'Useful for team-building: shows which professions are coverable by heroes and how each hero is unlocked.' It doesn't explicitly mention alternatives or when not to use it, but the context is clear enough for an agent to decide appropriately.

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 annotations (read-only, idempotent), the description discloses that results are compact records, limited by `limit`, and include a `total` count of all matches. It also explains that a full page is not the whole result, adding useful context about output volume and pagination 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 two sentences, front-loaded with the tool's purpose and filter options. The second sentence covers output behavior and redirects to get_skill. Every word earns its place; no fluff 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?

With an output schema present, thorough parameter descriptions, and annotations declaring the tool safe and idempotent, the description covers all essential aspects: what it searches, output limits, total count, pagination, and the alternative for full details. It is complete for a search/list tool.

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

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

The input schema has 100% parameter coverage with detailed descriptions for all 8 parameters, so the description doesn't need to add much. It summarizes the filter dimensions but does not provide syntax or format details beyond what the schema already offers. 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?

The description clearly identifies the tool as a search over the GW1 skill database with specific filter dimensions (profession, attribute, campaign, elite flag, name fragment). It distinguishes itself from the sibling get_skill by noting that get_skill provides full details, making it an obvious separate purpose.

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 points to get_skill for full details, providing an alternative tool for a different use case. It also gives concrete pagination guidance ('page with offset', 'a full page is not the whole result'), telling the agent when and how to page through results.

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 and idempotent, and the description adds useful behavioral context: it returns {valid, errors, warnings} and does not encode. It also implies a non-refusing behavior versus encode_template. 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?

Two sentences, front-loaded with the core function, and no wasted words. The second sentence concisely provides the return shape and directs to an alternative tool.

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

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

The description covers the validation rules, return structure, and the relationship to a sibling tool. With rich schema and output schema present, nothing critical is missing for an agent 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?

Schema description coverage is 100%, so the schema already explains each parameter thoroughly (e.g., exact English names, null for empty slot, rank 0-12). The description adds no new parameter detail beyond naming build components, so baseline 3 applies.

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

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

The description opens with a specific verb 'Check' and identifies the exact resource (build against GW1 rules), listing the validation categories. It explicitly distinguishes from the sibling encode_template, making the tool's 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 gives explicit when-to-use ('without encoding') and when-not-to-use guidance by directing to encode_template for template-code needs, noting that encode_template runs the same rules and refuses on errors. This is clear and actionable.

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