EcoCarbonWiki

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

With no annotations, the description carries the burden of behavioral disclosure. It states that output is Markdown and gives path format, but it does not mention error behavior, prerequisites, or any other limitations. This is adequate for a simple fetch operation but lacks depth.

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 core action, and every word contributes value. No redundancy or clutter.

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 single-parameter tool with no output schema, the description sufficiently covers the return format (Markdown) and provides usage examples. It is complete enough for an agent to invoke correctly, though it could note potential error cases.

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

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

The schema already documents the single 'path' parameter with an example, but the description adds extra context by showing additional valid forms like '/wiki' and '/wiki/recipes'. This enriches the meaning beyond the schema's baseline.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Fetch a single Eco wiki page as Markdown.' It also provides concrete path examples. However, it does not differentiate from sibling tools like wiki_get, leaving some ambiguity about when to use this over alternatives.

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

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

The description implies usage for fetching single wiki pages via canonical paths, but it does not explicitly state when to use this tool compared to siblings such as wiki_get or search. The examples provide context but no direct alternative 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?

With no annotations, the description carries the burden and does disclose the return format (ranked matches with name, kind, URL, snippet) and the full-text nature. However, it does not disclose pagination, search syntax, or edge-case behavior, leaving gaps.

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

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

The description is a single, well-structured sentence that efficiently states the operation, scope, and return fields 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?

For a simple 2-parameter tool with no annotations or output schema, the description covers the search domain, content types, and return format. It omits edge-case details but is otherwise sufficient for selecting this 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% (query required, limit optional with range). The description does not add any parameter-level detail beyond the schema, 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 clearly states a full-text search tool for the Eco game wiki, listing content types and return format. It does not explicitly differentiate from the sibling wiki_search, so it stops short of a 5.

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

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

The description implies usage for searching wiki content but provides no explicit guidance on when to use this tool versus alternatives like wiki_search. There are no exclusions or alternative recommendations.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly. It explains metric-field relationships ('count' needs no field; sum/avg/min/max require a field), the behavior of static fields with profiles ('static fields ignore it (the result carries a note)'), and the default ('No profile = base aggregate'). It also details profile-sensitive metrics explicitly (recipe labor/craft_minutes, tool damage/calories_burn/durability_burn, etc.), adding significant behavioral nuance beyond the 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 dense but well-structured. It front-loads the purpose, then gives usage guidance, examples, and profile-sensitivity details in a logical order. Each sentence earns its place—no filler. The use of inline JSON examples improves scannability and comprehension.

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

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

For a tool with 11 parameters, nested objects, and no output schema, the description is remarkably complete. It covers all key behaviors: metrics, filters, category scoping, profile recomputation, and default behavior. The examples illustrate typical queries and answer the implicit 'what does the result mean' question. It also appropriately delegates field-list details to wiki_rank rather than duplicating them.

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

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

Although schema coverage is 100%, the description adds substantial meaning beyond field names. It maps the `where` filter to a concrete example, clarifies that `category` mirrors wiki_rank, and explains how profile parameters (skills, talents, modules, server) interact with different field types. It also disambiguates count with/without a field, which is not fully expressed in the schema alone.

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

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

The description opens with a specific verb+resource+scope: 'Compute an aggregate over the wiki's entities — count / sum / avg / min / max of a numeric field across a whole kind, with an optional numeric where filter.' It clearly distinguishes from siblings like wiki_rank (ranking) and wiki_get (fetch) and mentions the same category scope as wiki_rank. The 'Use for...' phrasing reinforces its 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?

It explicitly states when to use: "Use for 'how many…', 'what's the average/total/highest…' questions." It also points to wiki_rank for per-kind field lists, which serves as a reference. However, it does not explicitly state when NOT to use it or name alternative tools for different tasks (e.g., ranking), only referencing wiki_rank for field lists rather than as an alternative.

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

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

With no annotations, the description carries full behavioral burden. It discloses key traits: transitive summation across the whole tree, primary-recipe selection with alternatives listed, optional ingredient filtering returning total+role, and server override behavior. It does not mention error handling or return format, but the disclosed behavior is substantial and non-contradictory.

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

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

The description is a dense but well-structured paragraph: definition first, then usage context, sibling distinctions, parameter walkthrough, and a concrete example. It is slightly long but every sentence adds value; the front-loading of the core purpose and differentiators makes it easy to scan.

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 10-parameter tool with nested objects and no output schema, the description is quite complete: it explains all parameter categories, gives an example, and covers the main use cases. The lack of an explicit return-shape description is a minor gap, but the example and behavioral details largely compensate.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond schema: it clarifies slug as target item or recipe, quantity as units of target with default/clamp, ingredient as specific component with role determination, and recipe_slug as override with alternatives. The example ties parameters together, enriching the schema.

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

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

The description opens with a specific definition: 'Bill-of-materials for making a target item/recipe: the full crafting tree INCLUDING the crafted intermediate sub-components (NOT just raw leaves).' It names the exact resource (crafting tree) and verb (compute BOM), and explicitly distinguishes from siblings wiki_total_raw and wiki_calc, eliminating ambiguity.

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

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

It states precisely when to use: 'This is the tool for "how many <component> does it take to make <target>"' and gives exclusions: 'Differs from wiki_total_raw (raw materials only) and wiki_calc (exact one-step numbers for a single recipe).' It also explains how to pass item vs recipe slug and optional overrides, providing clear usage context.

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

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

With no annotations, the description fully discloses behavior: it specifies exactly what is computed for each entity type (labor calories, craft time, XP, damage, yields), how parameters affect results, and that the response lists available modules/talents/skill with effect text. This goes well beyond a generic 'computes values' statement.

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

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

The description is long but information-dense and well-structured by entity type. The opening sentence front-loads the core purpose, and every subsequent clause adds specific calculation behavior without fluff, earning 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?

The tool is complex (9 params, nested server object, no output schema), yet the description covers all entity types, parameter scoping, server-override semantics, and even hints at response content by saying it lists available modules/talents/skill. This is complete enough for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds significant meaning by mapping parameters to entity types (e.g., skill_level for recipes/tools/mining, housing/variety/balanced/tastiness for food). It also explains that omitted levers use base values and that the response helps the user pick valid options, which aids correct parameter selection.

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 'Compute EXACT numbers for a chosen setup' and then enumerates specific outputs for recipes, food, tools, mineable blocks, and species. This clear verb+resource scope distinguishes it from sibling fetch/search/aggregate tools, which focus on retrieval rather than calculation.

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

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

The description provides clear operational context per entity type (e.g., 'Omit a lever to leave it at base' and 'Omit for accurate answers' regarding server override). However, it never explicitly names sibling alternatives or states when not to use this tool, so it lacks the full 'when/when-not' guidance needed for a 5.

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

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

With no annotations provided, the description carries the full burden. It transparently outlines the tool's scope (kinds, rewards/escrow, completion verification) and its read-only explanatory nature via the verb 'explain.' It does not delve into return format or limitations, but for a simple knowledge tool this is sufficient.

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

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

The description is two sentences, front-loaded with the core purpose and followed by a usage hint. Every word earns its place, and there is 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?

For a zero-parameter, no-output-schema tool, the description fully covers what the tool does and when to use it. It specifies the topic (Solomon's help contracts/quests), the subtopics (kinds, rewards/escrow, verification), and the trigger question type. There is no missing context that would confuse an agent.

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 tool has zero parameters, so the input schema is empty and schema coverage is 100%. The baseline for 0-param tools is 4, and the description correctly implies that no arguments are needed. No additional parameter semantics are 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?

The description uses a specific verb ('Explain') and clearly identifies the resource ('Solomon's help contracts and quests') and the aspects covered (kinds, rewards/escrow, completion verification). This distinguishes it from sibling wiki tools that are generic fetch or search operations, making the purpose immediately clear.

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 phrase 'Use for "how do contracts/quests work" questions' provides explicit context for when to select this tool. It does not explicitly mention when not to use it or name alternatives, but the guidance is clear enough for an agent to make a correct choice.

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

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

With no annotations, the description carries the full burden. It discloses the read-only nature implicitly and details what each kind returns. It also mentions ambiguous slug behavior and batching efficiency. However, it does not specify error handling for missing slugs or the exact response structure, leaving minor gaps.

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

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

The description is long but appropriately structured with a clear opening statement and a bulleted list for the six kinds. Every sentence adds value, explaining the tool's scope, batching benefit, and kind-specific details. No fluff.

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

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

Given the tool's complexity and lack of output schema/annotations, the description thoroughly covers what each kind of page returns. It omits explicit mention of the response format (e.g., JSON structure) but provides sufficient detail for an agent to understand the data content. Slightly incomplete on error handling and response shape.

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 includes basic descriptions, but the tool description greatly expands on the 'kind' parameter by explaining all six enum values and the specific facts each kind returns. It also gives context for 'slug' (from wiki_search) and batching advice, adding significant meaning beyond the schema.

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

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

The description clearly states the tool 'Read full facts for one OR MANY wiki pages in a single call' with specific resource (wiki pages) and a unique batching capability. It distinguishes itself from siblings by detailing the six page kinds and explicitly referencing wiki_calc and wiki_total_raw as alternatives for specific needs.

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

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

Provides explicit usage guidance: 'Pass every page you need at once' to save round-trips, and instructs to obtain slugs 'from wiki_search'. It also says to omit kind if unsure and explains that ambiguous slugs return all matches. References to wiki_calc and wiki_total_raw give clear alternatives for derived calculations.

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

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

With no annotations, the description carries full burden and does not disappoint: it explains bool encoding (1/0), that non-applicable fields exclude the entity, default order/limit values, profile sensitivity rules, and even notes that a 'result carries a note' when profile is ignored. This goes well beyond a minimal behavioral disclosure.

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

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

The description is long but carefully structured with bullet lists, examples, and sectioned parameter explanations. Every section earns its place, though the exhaustive item-field list makes it slightly verbose. It is front-loaded with the core purpose, so readers quickly understand the tool before diving into details.

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

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

Despite lacking an output schema, the description makes the return value clear through examples (e.g., 'the 3 highest-calorie foods') and the note about profile-sensitive results. Given the tool's complexity (12 params, 5 entity kinds, many fields), the description covers all necessary context—parameters, edge cases, and profile behavior—making it effectively 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?

The input schema descriptions are terse and defer to the main description for meaning. The description supplies the actual field names per kind, examples of valid 'where' filters, and explains how category, server, skills, modules, and talents affect ranking. This richly compensates for the schema's brevity despite 100% schema coverage.

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

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

The description opens with a precise verb+resource: 'Rank the wiki's entities by a NUMERIC field and return the top (or bottom) N.' It also explicitly distinguishes itself from siblings by stating this is for 'ANY which has the most/least/highest/lowest X' question and warns against using wiki_search for such cases.

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 states when to use it ('Use this for ANY...') and when not to ('never guess-and-confirm with wiki_search'). It provides detailed parameter guidance, examples, and per-kind field lists, plus a clear statement about profile-sensitive vs. static fields, making usage 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?

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states what the tool returns (matching pages with kind, name, slug, snippet) and scopes the search to the Eco game wiki. It does not mention edge cases like empty results or relevance ordering, but the core behavior is well specified.

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 plus one imperative, front-loaded with the core purpose and immediately followed by output details and usage guidance. No wasteful words; every sentence earns its place.

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

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

For a simple search tool with two well-documented parameters and no output schema, the description covers the purpose, return fields, and the follow-up action (using the slug). It lacks explicit mention of result ordering or limit behavior, but the limit parameter is documented, and the overall guidance is sufficient for an agent to invoke 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?

Both parameters have comprehensive schema descriptions, including examples, so schema coverage is 100%. The tool description adds minimal parameter semantics beyond reinforcing the search context; the baseline of 3 is appropriate because the schema already carries the main 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?

The description clearly states the tool performs full-text search on the Eco game wiki and enumerates the content types covered. It also differentiates itself from sibling tools by explaining that it returns slugs for use with wiki_get_* tools, making the purpose and role unambiguous.

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

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

The description provides an explicit workflow: 'ALWAYS search first to find the right slugs' and directs the user to use the returned slug with wiki_get_* tools. It does not explicitly list alternatives or when not to use the tool, but the 'always search first' rule strongly implies a prerequisite for other wiki lookup tools.

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

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

With no annotations, the description carries behavioral disclosure. It explains the computation scope (whole production chain), that either item or recipe slug works, and that optional parameters recompute the entire chain. It also notes server override semantics (default is this server's real settings). It does not mention error handling or return format, but for a computation tool this is fairly transparent.

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

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

The description is two sentences: first states the core action and outputs, second gives usage context, alternative, and optional parameters. Each part earns its place, and it is front-loaded with the main purpose.

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 params, nested objects, no output schema), the description covers the primary use case, distinguishes from sibling, and explains optional parameter effects. It could mention output shape but that's not strictly required. Overall it is complete enough for an agent to select and invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds useful context: slug accepts item or recipe, and character/server overrides affect the whole chain. It also clarifies the difference between module parameter and modules array. This goes beyond mere schema descriptions.

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

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

The description clearly states the tool's purpose: flatten a recipe or craftable item to total raw materials, with labor calories, craft minutes, and step count. It distinguishes itself from sibling wiki_bom by explicitly saying wiki_bom gives intermediate sub-components, while this tool gives the raw shopping list.

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

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

Provides explicit use case: 'what does it take to make X from scratch'. It names the alternative tool (wiki_bom) for when you need intermediates, and explains when to use optional character/server overrides. This is very clear guidance.

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