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

With no annotations, the description must carry the behavioral burden. It discloses that output includes construction times, required items, trader loyalty, and required stations, plus the notable behavior that 'Item/station ids are resolved to names.' It does not mention error behavior or explicitly confirm read-only status, but 'get' implies no side effects.

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

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

Two sentences with no fluff. The core purpose and selection method are front-loaded, followed by a concise list of included details and a behavioral note. 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?

The description adequately explains what data will be returned for a single-station lookup, even without an output schema. It does not cover edge cases like 'not found' behavior, but for a simple get-by-id/name tool, the provided detail is largely sufficient.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by clarifying that idOrName accepts either an ID or a name and by highlighting that IDs are resolved to names in the output, which helps agents understand parameter behavior.

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: 'Get full detail for one hideout station by id or name' and enumerates the contained data. It clearly differentiates from the sibling list_hideout_stations by emphasizing 'one' and 'full detail'.

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 usage context is clear: this tool is for retrieving a single hideout station's detailed informationtons, while list_hideout_stations exists for enumeration. However, it does not explicitly name the alternative or state when not to use this tool, which would merit 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 of explaining behavior. It usefully discloses that referenced trader and item ids are resolved to names, which is a meaningful behavioral detail beyond what the schema shows. It does not address not-found behavior or response shape, but for a read-only lookup the disclosed behavior is reasonably 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?

Two tightly written sentences lead with the core action and resource, then list the most informative result contents. Every clause adds value; there is no filler or repetition.

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

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

The description gives a good high-level account of the return contents, which matters because there is no output schema. Combined with fully documented input parameters, an agent has enough to invoke the tool correctly. It stops short of enumerating all possible item property categories or error cases, but it is complete for typical use.

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

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

Schema coverage is 100%, so the parameters are already well documented with types, enums, defaults, and examples. The description adds little beyond saying lookup can be by id or name, which is already captured in the idOrName parameter description. This meets the baseline for schema-bearing 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 identifies the operation: retrieving full detail for a single item by id or name. It also enumerates what those details include (flea market pricing, trader offers, weapon/armor/ammo properties), which distinguishes it from search_items and get_item_price_history.

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

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

The description implies the right usage context: when you need comprehensive, item-level detail for a known id or name. It does not explicitly name alternatives or exclusion conditions, but the scope is clear enough that an agent can infer this is the targeted lookup versus broader search or price-history 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 provided, the description carries the behavioral disclosure burden. It usefully discloses the default 30-day window and that full history can span years and thousands of points, but it does not mention output structure, error behavior, or authentication requirements.

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 with no filler. The core purpose is front-loaded, and the important default behavior is stated immediately after. 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 query tool with fully documented parameters, the description covers purpose, returned data points, and key default behavior. It does not explain return formatting, but there is no output schema and the schema covers parameter semantics adequately.

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 all three parameters. The description adds context for the `days` parameter by explaining the default and how to widen the window, but it does not meaningfully enrich `idOrName` or `gameMode` 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 states a specific verb ('Get'), resource ('flea market price history'), and scope ('for one item'), and lists the returned data points (min price, average price, timestamp). It is clearly distinct from siblings like get_item or search_items, though it does not explicitly name an 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?

No guidance is given on when to use this tool versus siblings such as get_item or search_items. The description implies it is for price history queries, but it does not state exclusions or alternatives, leaving tool selection to inference.

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

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

With no annotations present, the description carries the full burden and discloses a non-obvious behavioral default: raw coordinate/outline data is omitted by default, with a rationale and explicit opt-in via includePositions. It does not describe error or matching behavior, but for a read-style lookup this is solid transparency.

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

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

Two sentences, front-loaded with purpose and immediately followed by the most important behavioral caveat. The examples and the explanation for excluding raw coordinates all earn their place without padding.

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

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

Despite having no output schema and no annotations, the description tells the agent what the response contains, what is excluded by default, and how to get the excluded data. For a single-map detail lookup, nothing essential 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 the baseline is 3; the description adds real value by explaining includePositions in behavioral terms and giving realistic idOrName examples. It also clarifies what response content the tool returns, which helps the agent map parameters to expected output.

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

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

Description uses a specific verb and resource ('Get detail for one map by id or name') with concrete examples ('Customs', 'Factory'), and enumerates the content returned: extracts, hazards, boss spawn chances and zones, transits, access requirements. The singular scope distinguishes it from sibling list_maps without needing to name it.

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

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

The description clearly frames when the tool is appropriate: retrieving details for a single map by id or name, and it explains when to add coordinate data by setting includePositions. It does not explicitly name list_maps or other alternatives, so it misses a full when/when-not routing statement.

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. It discloses freshness ('Always fetched fresh, not cached') and live status, but does not mention return format, rate limits, or any side effects. For a no-parameter read-only tool, this is acceptable but not rich; a description of what the response contains would be better.

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 short sentences, front-loaded with the core action and resource, followed by a key behavioral note. No wasted 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 no-parameter, no-output-schema status check, the description tells the agent what the tool does and that it is fresh. It could add a hint about the response structure (e.g., per-component status), but it is not essential for a correct call. Adequate for the complexity level.

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 schema coverage is trivially 100% and there is nothing to explain. The description correctly implies no inputs are required, and no parameter documentation is needed.

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 ('Get'), a clear resource ('live status of Escape from Tarkov's servers'), and enumerates components (website, launcher, game servers). It is unambiguous and clearly distinct from sibling tools, which are all item/trader/map/task lookups.

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 when to use it ('current live status', 'Always fetched fresh') and the sibling tools are unrelated, so no explicit exclusions are needed. It provides clear context that this is a real-time check, though it does not explicitly name an alternative or a 'when not to use' scenario.

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?

No annotations are provided, so the description must carry the behavioral burden. It discloses that trader/item/map ids are resolved to names, which is a useful behavioral detail. It also implies a read-only operation ('Get'), though it doesn't explicitly state side effects or permissions. Given the simplicity, this is adequate.

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 with no filler. The primary purpose is front-loaded, and the second sentence adds a valuable detail about id resolution. Every word earns its place.

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

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

Given the tool's simplicity (3 params, no output schema), the description provides a good overview of what the result contains (objectives, requirements, rewards, failure outcomes) and the id-resolution behavior. It doesn't cover error cases or return format, but that's not critical for a single-fetch tool. Sibling tools like search_tasks are not mentioned, but the usage is clear.

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

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

Schema description coverage is 100%, so all parameters have descriptions. The description adds no additional parameter semantics beyond clarifying that idOrName can be either an id or a name, which the schema already states. It does not elaborate on lang or gameMode, but the schema enums and defaults cover them. Baseline 3 is correct.

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 ('Get') and resource ('full detail for one task/quest') and lists the content (objectives, requirements, rewards, failure outcomes). It distinguishes from search_tasks by specifying it retrieves a single task by id or name, and from get_item/get_trader by focusing on tasks. The mention of id-to-name resolution adds a distinguishing feature.

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

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

The description clearly implies usage: when you have a task id or name and need full detail. It doesn't explicitly mention alternatives or when not to use it, but the context is clear. No exclusions or alternative routing is provided, so a 4 is appropriate.

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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It does reveal the returned content (loyalty levels, buy/sell restrictions) and implies a read-only operation through 'Get', but it does not mention error behavior, authentication, rate limits, or any potential side effects. For a simple retrieval tool this is adequate but not rich.

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 definition is a single, tightly scoped sentence that front-loads the main action and resource, then adds return details. Every phrase earns its place, with no filler or repetition of schema information.

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

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

Given the absence of an output schema, the description does well to specify the main return categories (loyalty levels, buy/sell restrictions). It does not enumerate every possible field, but 'full detail' plus those examples gives adequate context for an agent to judge the tool's usefulness. It also implicitly covers the key parameters in the schema. Slightly more detail about response structure would make it fully 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 description coverage is 100%, so the baseline is 3, but the description adds meaningful value for the primary parameter 'idOrName' by specifying 'by id or name' and giving real examples ('Prapor', 'Therapist'). This clarifies the accepted format better than the schema's generic 'Trader id or name'.

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 ('Get') and resource ('full detail for one trader'), and clarifies the lookup key ('by id or name') with concrete examples ('Prapor', 'Therapist'). It also names the returned content (loyalty levels, buy/sell restrictions), which distinguishes it from sibling 'list_traders' by scope (one vs all).

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 usage context is clear: use this tool to retrieve full details for a single trader. It does not explicitly name alternatives or state when not to use it, but the specificity of the purpose ('for one trader') makes the appropriate situation obvious. No exclusions are stated, but the guidance is strong enough for an agent to select it correctly.

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

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

No annotations exist, so the description carries the behavioral burden. It does disclose the read-only listing behavior and the included max-level field, but it does not mention ordering, pagination, or how lang/gameMode affect results. For a simple list tool, this is acceptable but not richly 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 a single front-loaded sentence with no filler. The parenthetical examples clarify the resource type without adding bulk, and the key return field is included.

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

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

For a low-complexity tool with two fully documented optional parameters and no output schema, the description covers the essential missing context: scope and the included max-level field. It is sufficient, though ordering or response-shape details could have added extra completeness.

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

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

Schema description coverage is 100%, and both lang and gameMode already have meaningful enum-based descriptions with defaults. The tool description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('List'), names the resource ('hideout stations'), and clarifies scope with 'all' and representative examples. It also states the key returned attribute (max level), making the purpose unambiguous and distinguishing it from the singular get_hideout_station.

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 collection-level usage by saying 'List all', which contrasts with the singular sibling get_hideout_station. However, it does not explicitly state when to use this tool versus the sibling or provide any exclusion criteria.

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 behavioral burden. It clearly states the output content (maps with raid duration, player count, enemy types) and implies a read-only, non-destructive operation. It does not mention auth, rate limits, or pagination, but for a simple list tool these are unlikely to be concerns. It adds the specific return fields, which is useful 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 a single sentence, front-loaded with the action and resource, and immediately enumerates the included data fields. It contains no fluff or repetition, making it highly efficient and easy to parse.

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

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

The tool has 2 optional parameters, no required ones, and no output schema. The description sufficiently explains the return value (a list of maps with specified attributes). It does not describe how lang/gameMode affect output, but the schema covers that. Given the simplicity of a list operation, nothing essential 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%, as both parameters (lang and gameMode) are documented in the input schema. The description adds no extra meaning about parameters, so it relies on the schema. Per the calibration rule, high schema coverage yields a baseline of 3.

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

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

The description uses a clear verb ('List') with a specific resource ('all Escape from Tarkov maps') and enumerates the included attributes (raid duration, player count, enemy types). This distinctly differentiates it from siblings like get_map (which likely returns a single map) and list_hideout_stations (which covers a 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?

The description implies usage—'List all maps' signals it is for retrieving the full set—but it does not explicitly mention when to use this tool versus get_map for a specific map. No alternatives or exclusions are named, so the guidance is only implicit.

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 behavioral burden, but the verb 'List' clearly signals a read-only operation. It adds concrete output expectations (currency, restock/reset time) without needing to warn about side effects since none are plausible for a listing operation.

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

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

A single sentence with no redundant words; the core action and the two key output fields are front-loaded. Every part 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 low-complexity list tool, the description plus fully described schema is sufficient to call it correctly. It lacks a note about response shape, but the stated fields (currency and reset time) cover the main return expectations.

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

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

Schema coverage is 100% and both parameters (lang, gameMode) have enum values and descriptions in the schema. The tool description adds no parameter-specific meaning, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('List') and resource ('all Escape from Tarkov traders'), and adds the output fields (currency, next restock/reset time). This clearly distinguishes it from singular sibling get_trader and other list tools like list_hideout_stations.

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 plural scope and 'all' imply use when a complete trader overview is needed, but the description never states when not to use it or points to get_trader for a single trader. Usage guidance is only implied, not 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose one helpful behavior—that item and trader IDs in results are resolved to names—but it does not describe response structure, pagination, or any other operational details. It is not misleading, but coverage is only partial.

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 with no wasted words. The core purpose and filter scope are front-loaded, and the parenthetical explanation adds clarity without bloating the text.

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

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

For a simple read-only search tool with fully documented parameters, the description is nearly complete. It explains the resource, the filters, and one key output behavior; only the lack of an output schema means the return shape is not explicitly described, but this is not critical for invoking the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description reinforces the item/trader filter relationship and the ID-resolution behavior, but it does not add significant meaning beyond what the parameter descriptions already provide.

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 ('Find') and resource ('trader barter offers'), and clarifies the concept with 'trade items instead of paying cash.' This clearly distinguishes barters from cash purchases and from sibling tools like search_items and search_crafts.

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

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

The description clearly implies when to use the tool: when looking for barter trades involving a particular item and/or trader. It does not explicitly name alternatives or exclusion criteria, but the context is clear enough that an agent can route correctly without further inference.

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

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

With no annotations, the description carries the behavioral disclosure burden. It establishes a read/search tone with 'find' and adds a concrete behavior: item/station IDs in results are resolved to names. It does not disclose behavior when no filters are provided, pagination behavior, or result structure, but for a non-destructive search tool the core risk is low.

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 compact sentences that front-load the search purpose and add one relevant output detail. Every sentence earns its place, with no filler or redundancy with the schema.

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 plus schema cover the input parameters and core search intent well. However, there is no output schemahol and the description does not describe what fields a craft recipe result contains or what happens when both itemId and station are omitted. That leaves some uncertainty about expected results.

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 each parameter. The description contributes a small clarification that itemId/station jointly define what is 'involved' and that IDs are resolved in output, but it adds no material meaning beyond the schema for lang, limit, or gameMode.

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

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

The description uses a specific verb and resource ('find hideout craft recipes') and clearly defines the filtering dimensions: item and/or hideout station. 'Hideout craft' differentiates it from sibling tools like search_barters and search_items, even without naming them. The operation is 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 intended usage is implied: use this tool when looking for hideout craft recipes that involve a particular item or station. However, it never explicitly states when not to use it or points to alternatives such as search_barters or get_hideout_station, so an agent may not route perfectly between related 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 the behavioral burden and does well: it discloses substring matching, optional filters, and that returns are compact summaries rather than full item data. It does not discuss pagination or error behavior, but for a read-only search tool the key behavioral traits are covered.

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 tightly written sentences with no filler: purpose and matching semantics first, then optional filters, then return behavior and the pointer to get_item. Every sentence earns its place.

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

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

Given there is no output schema, the description adequately explains return values (compact summaries with id, name, prices) and the fallback to get_item. The remaining details like defaults and limits are already fully covered by the input schema.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value beyond the schema: it defines query as substring matching over name/shortName/normalizedName, clarifies what the type filter values mean, and specifies that trader matches buy or sell relationships.

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 ('Search'), resource ('Escape from Tarkov items'), match semantics ('name/short name ... substring match'), and optional filters. It clearly distinguishes itself from get_item by noting that it returns compact summaries while get_item provides full detail.

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 says to use get_item when full detail on one item is needed, giving a clear alternative condition. It does not mention other sibling tools like search_barters or search_crafts, but the target resource and filter behavior are clear enough to route an agent correctly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully discloses that results are compact summaries and points to get_task for full detail. However, it does not mention ordering, pagination behavior, error cases, or any side effects. For a read-only search tool this is acceptable but not rich.

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 with no filler. It front-loads the core behavior, then immediately provides the key differentiator and routing to get_task. Every word 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 search tool with six fully documented parameters and no output schema, the description gives enough context to call it correctly: it explains the search mechanism, optional filters, result granularity, and the alternative for full details. It could mention result ordering or default limit, but those are already in the schema, so the description is reasonably complete.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds useful context for query (substring match) and for trader/map filters, but it does not significantly extend the meaning of lang, limit, or gameMode beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool searches tasks/quests by name with substring matching, and optionally filters by trader and/or map. It also explicitly distinguishes itself from get_task by noting that search_tasks returns compact summaries while get_task provides full details. This gives an agent a precise understanding of the tool's scope and differentiates it from its siblings.

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 the agent when to use this tool versus an alternative: use search_tasks for compact summaries, and use get_task for full objectives/requirements/rewards. This is direct, actionable guidance that leaves little to inference.

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