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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety/scope profile is covered. The description adds no behavioral detail beyond that – no mention of the default limit, pagination, or what the country-by-country payload looks like. Adequate but thin against an already-informative annotation set.

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 with zero filler; the core capability is front-loaded and the usage hint follows immediately. Nothing could be trimmed without losing substance.

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 read-only lookup with fully documented parameters and no output schema, the description covers purpose and intent sufficiently for correct invocation. It could add a note on the returned price shape or per-country response, but 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%, so all three parameters (ulke, limit, abonelik_id) are already documented in the schema, including defaults ('Boşsa hepsi', default 200) and the source of abonelik_id. The description adds no syntax or meaning beyond the schema, 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?

States a concrete verb and resource: it fetches a subscription's prices country by country ('Bir aboneliğin ülke ülke fiyatlarını getirir'). This distinguishes it from the sibling appstore__abonelikler (which manages the subscription itself), but the description never names or explicitly contrasts that sibling.

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

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

Gives a clear usage trigger with an example question type ('Bu abonelik Türkiye'de kaça' türü sorular için), which tells the agent exactly which user intents map to this tool. It does not, however, state when NOT to use it or point to alternatives like play__abonelik_fiyatlari.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful return-content context (productId, duration, status), but discloses nothing about pagination, auth scope, or filtering limits. 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?

Two tightly-scoped sentences with the core action front-loaded and the return fields appended. No wasted text; only slightly terse for a tool with an undocumented output shape.

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 one-parameter read tool with annotations covering safety and no output schema, listing the returned fields (productId, duration, status) is enough for correct invocation. Missing only pagination/ordering details, which are minor here.

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

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

Schema coverage is 100% and the single parameter uygulama_id is fully documented in the schema as coming from appstore__uygulamalar. The description adds no syntax, format, or sourcing detail beyond the schema, so 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?

States a specific verb ('listeler') and a precise resource ('abonelik gruplarını ve içlerindeki abonelikleri'), which is distinguishable from sibling appstore__abonelik_fiyatlari (prices) and play__abonelikler. It also names the returned fields. However, it does not explicitly contrast itself with any sibling tool, so it falls short of the 5 bar tied to sibling differentiation.

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?

There is no explicit when-to-use guidance, no alternatives (e.g., appstore__abonelik_fiyatlari for pricing) and no exclusions or prerequisites. The purpose merely implies a usage context, and no routing help is offered.

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, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds genuine behavioral value beyond that: results are ordered newest-first and each entry surfaces processing status and expiration date, which shapes how an agent interprets the output.

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 short, front-loaded sentences with the core capability stated first and the ordering rule and use-case scoping appended. Minimal waste, though the closing question sentence lightly restates the already-clear 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?

For a read-only list tool with no output schema, the description usefully declares the key fields returned (processing status, expiration) and the sort order. Parameters are fully covered by the schema, so nothing essential is missing, though it could note whether results are paginated.

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

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

Schema description coverage is 100%, so both parameters (limit, uygulama_id) are already documented in the schema; baseline is 3. The description adds no extra detail about the limit default or the filtering semantics beyond what the schema 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?

States a specific verb and resource: listing TestFlight builds, with the added scope of processing status and expiry date. It clearly distinguishes its content from the sibling appstore__testflight_gruplari, but never explicitly names or contrasts with that sibling, so it falls 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?

Gives a concrete usage scenario ('is my uploaded build ready?') that tells the agent when this tool is the right call. It offers no explicit when-not or alternative-routing guidance (e.g. vs testflight_gruplari), so it stops at clear-context-without-exclusions.

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, openWorldHint=true, destructiveHint=false, so the safety profile is covered and the description is consistent with it. The description adds no behavioral context beyond that (no pagination behavior, no return shape), so it does not exceed the annotation baseline.

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 front-loaded sentence with zero waste; the scope qualifier that matters most for disambiguation is appended immediately.

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 two-parameter read-only list tool with full schema coverage and annotations, the description is sufficient; no output schema exists so return values need not be explained. Minor shortfall is the absence of any note on whether results are paginated via limit.

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% – both uygulama_id and limit are documented in the schema. The description adds no syntax, format, or default information for either parameter, so 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?

Specific verb (listeler) plus resource (tek seferlik uygulama içi satın alma ürünleri) with an explicit scope qualifier (abonelik olmayanlar) that separates it from the sibling appstore__abonelikler. An agent can route between this and the subscription tool without opening either schema.

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

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

The parenthetical 'abonelik olmayanlar' implies subscriptions live elsewhere, giving implied usage context, but no alternative tool is named and there is no when/when-not guidance. Adequate but with clear gaps.

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 declare destructiveHint=true and readOnlyHint=false, so the mutation profile is known. The description adds genuinely new behavioral context beyond the annotations: the published-version immutability rule, which materially affects whether the call will succeed. It does not describe rollback or side effects, but it adds real value over the structured fields.

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

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

Two sentences, zero waste. The action and affected fields come first, and the critical editing constraint is front-loaded second. Nothing redundant.

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 mutation tool with no output schema but full annotation coverage and a 100%-documented schema, the description supplies the needed editing-scope constraint. It omits confirmation/error behavior, but that gap is minor given the onayla parameter and annotations already convey the destructive/open-world profile.

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 each parameter carries its own description (including the onayla confirmation flag and the localization-id lookup path), so the schema does the heavy lifting. The description's field list ('sürüm notları, açıklama, anahtar kelimeler, tanıtım metni') loosely maps to the params but adds no format or constraint detail beyond it – baseline 3.

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

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

The description states a specific verb and resource ('Bir sürümün mağaza metinlerini günceller') and enumerates the editable fields (release notes, description, keywords, promo text). No sibling performs this edit, so the agent can identify the tool, though it never names or contrasts a sibling explicitly.

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

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

It gives a clear applicability constraint: only the in-preparation version can be edited, not the published one. This is strong when-to-use guidance, but it does not name an alternative tool for related operations or state prerequisites beyond the version state.

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?

Anotasyonlar salt-okunur ve yıkıcı olmayan profili zaten veriyor; açıklama buna ek olarak Apple'ın yayın gecikmesini, boş günlerde dosya üretilmemesini ve SUBSCRIBER için DETAILED zorunluluğunu ekliyor. Yetkilendirme gereksinimleri veya dosyanın nereye indirildiği belirtilmemiş.

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?

Dört cümle, ana amaç öne alınmış ve her cümle operasyonel bir bilgi taşıyor. Gereksiz tekrar veya dolgu yok.

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?

Çıktı şeması olmadığından açıklama dönüş biçimini (TSV) üstleniyor ve önemli tuzakları (gecikme, eksik dosyalar, alt tür kısıtı) kapsıyor. Dosyanın nasıl döndürüldüğü/kaydedildiği yönü eksik, bu da tek boşluk.

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?

Şema açıklama kapsamı %100 olduğundan her parametre zaten belgelenmiş; bu taban çizgisi 3'tür. Açıklama, SUBSCRIBER raporunun yalnızca DETAILED ile çalıştığını ve sürüm numarası gerektirdiğini ekleyerek alt_tur–tur–surum arası ilişkiye dair bir miktar ek değer katıyor, ancak şemadakilerle büyük ölçüde örtüşüyor.

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?

Uzun bir fiil+nesne ifadesi veriyor ('Satış ve indirme raporunu indirir') ve çıktı biçimini (TSV) belirtiyor. Kardeş araçlardan hiçbirini adlandırarak ayrıştırmıyor, ancak bu araç kardeş listesinde benzersiz bir rapor indirme işlevi görüyor.

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?

Raporların 1-2 gün gecikmeli yayınlandığını ve satışsız günler için dosya üretilmediğini belirtiyor; SUBSCRIBER alt türü kısıtını ve sürüm numarası gereksinimini açıklıyor. Ancak bir alternatif araç önerilmiyor veya 'şu durumda bunun yerine şunu kullan' yönlendirmesi yok.

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, openWorldHint=true and destructiveHint=false, so the safety profile is covered elsewhere. The description adds the set of possible status values, which is useful domain context, but says nothing about pagination behavior, ordering, or freshness of the data. 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?

Two short sentences, zero filler, with the core capability front-loaded and the use-case question placed after it. Every clause 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 two-parameter read tool with no output schema, the description conveys what is returned (versions plus their statuses) well enough to call it correctly. Minor gaps around ordering and result count are covered by the 'limit' parameter default.

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%: both 'limit' (default 10) and 'uygulama_id' (sourced from appstore__uygulamalar) are fully documented in the schema. The description adds no parameter meaning beyond that, 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 names a specific verb (listeler) and resource (App Store sürümleri) scoped to one app, and enumerates the status values it returns. It is clearly distinguishable from sibling resources like appstore__uygulamalar and appstore__buildler, though it never states that distinction explicitly.

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

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

It supplies a concrete usage context ('Hangi sürüm incelemede takıldı' sorusunun cevabı burada), which tells the agent which question this tool answers. It stops short of naming when-not-to-use or pointing to an alternative sibling tool.

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, openWorldHint=true and destructiveHint=false, so the safety profile is covered structurally. The description adds only the returned shape (groups plus per-group test user counts) and says nothing about pagination, ordering, or auth scope.

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 front-loaded sentence with no filler or redundancy. It is appropriately sized; it simply does not use the available space to add routing or behavioral context.

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 one-parameter, read-only list tool with a fully documented schema and no output schema, the description conveys both what is listed and a key part of the return (test user counts), and annotations cover safety. Adequate, though sibling routing is absent.

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 schema already explains that uygulama_id comes from appstore__uygulamalar. The description adds no format or sourcing detail beyond that, so 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?

States a specific verb (listeler) and resource (TestFlight beta grupları) and even specifies the payload (test kullanıcı sayısı per group), so the agent knows exactly what comes back. However, it does not name or contrast with any sibling tool, 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many sibling appstore__/play__ tools. Usage must be inferred entirely from the name and resource noun.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the payload shape (ad, bundle ID, App Store ID, birincil dil), which is useful context the annotations do not provide, though it says nothing about pagination or default ordering.

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 short sentences, front-loaded with the listing action and followed by return fields and the reason to call it. Every sentence carries information with no filler.

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

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

With no output schema, the description compensates by naming the returned fields, and it explains the tool's role as an id source for sibling tools. Only minor gaps remain (pagination behavior, filtering semantics) for a simple two-parameter 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?

Schema coverage is 100% and both parameters (limit, isim_filtresi) are documented in the schema itself. The description adds no semantics beyond that, so a 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?

States a specific verb and resource ('App Store Connect hesabındaki uygulamaları listeler') and immediately enumerates the returned fields, so the agent knows exactly what this yields. The 'App Store Connect' scoping also implicitly separates it from the Play Store sibling (play__uygulamalar).

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

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

It gives a clear reason to call it first: 'Diğer araçların çoğu buradaki id değerini ister,' telling the agent this is a prerequisite for id-consuming tools. There is no explicit when-not or named alternative, so it falls short of 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?

Annotations already declare read-only, non-destructive, open-world behavior. The description adds useful context beyond that: results are sorted newest to oldest, can be filtered by rating or country, and existing developer replies are included. It does not mention pagination or rate limits, so not a 5.

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?

Four sentences, front-loaded with the core action, and each sentence earns its place by covering filtering, sorting, use cases, and the inclusion of existing replies. No redundant or vague phrasing.

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 read-only, open-world list tool with full parameter coverage and no output schema, the description covers purpose, filters, sorting, and reply inclusion. It could optionally state the return shape per review or pagination behavior, but the essentials are present.

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 are fully documented in the input schema. The description mentions filtering by rating or country, which maps to two parameters, but adds no syntax or format details beyond what the schema already 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 states a specific verb (getirir) and resource (App Store müşteri yorumları), and the App Store qualifier distinguishes it from the Play sibling (play__yorumlar) and from the reply tool (appstore__yorum_yanitla). However, it does not explicitly name an alternative, so it falls just 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?

It gives clear when-to-use scenarios: summarize reviews, find complaints, or prepare response drafts. It also notes filtering and sorting behavior. It does not state when not to use it or name an alternative tool, so no explicit exclusions.

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 the tool is a destructive, non-read-only, open-world operation, so the safety profile is covered. The description adds a genuinely useful behavioral trait those annotations do not convey: the response only goes live after Apple moderation. It stops short of stating edit/overwrite semantics for an existing developer reply.

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, the action front-loaded and the moderation caveat immediately following. No filler whatsoever.

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 mutation tool with no output schema, the description covers the action and the delayed-publication outcome, and annotations carry the destructive/open-world signal. Minor gaps remain around permissions and whether an existing reply can be replaced.

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 every parameter (yanit, onayla, yorum_id) is already documented, including the 5970-character limit and the confirmation flag semantics. The description adds nothing beyond that, so 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 gives a clear verb+resource: writing a developer response to an App Store review. Naming 'App Store' implicitly distinguishes it from the sibling play__yorum_yanitla, but it never explicitly routes between the two platform variants.

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?

There is no when-to-use guidance, no prerequisites, and no mention of the alternative sibling (play__yorum_yanitla for Google Play, or appstore__yorumlar for reading reviews first). The agent must infer the context entirely.

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 and openWorldHint=true, so safety is covered. The description adds meaningful output behavior beyond annotations: it specifies that the result surfaces price differences between stores and flags missing products, not just raw subscription data. Return format and pagination are unstated, which is a minor gap.

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 action and the store scope, then immediately stating the value added. No redundant restatement of the tool name or filler.

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

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

There is no output schema, but the description specifies the compared fields and the anomalies caught, which is the essential return content an agent needs to set expectations. Safety is covered by annotations. Missing pagination or response-shape detail is a minor gap for this comparison tool.

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

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

Schema description coverage is 100%, so the country code conversion (TUR/TR) and the dual-store app lookup semantics are fully documented in the schema. The description references requested-country prices but adds no syntax or defaults beyond what the schema already provides, so the 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?

States a specific verb 'karşılaştırır' (compares), the resource 'abonelikler' (subscriptions), and the cross-store scope spanning App Store and Google Play. It enumerates the compared fields (product ids, durations, prices) and the detected anomalies (price differences, missing products), making it clearly distinct from single-store siblings like appstore__abonelikler and play__abonelikler.

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 cross-store comparison scope implicitly tells the agent when this tool is preferred over the single-store subscription tools, and the 'iki mağaza arasındaki' framing excludes single-store use. However, it never names an alternative explicitly or states a when-not condition, so it falls short of 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, openWorldHint=true; the description adds the human-confirmation gate and the verb-based rule that selects it, which is genuinely new behavioral context. It stops short of describing rate limits, auth requirements, or what a failed/approved call returns.

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 short sentences, zero filler: capability first, discovery step second, safety gate third. Ideal front-loading for a dispatcher 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?

For a nested-object gateway with no output schema, it covers the key unknown (how to obtain a valid operation name) and the safety precondition. It omits what the response looks like and whether results are store-specific, a minor gap given the schema does the parameter work.

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 five parameters are already documented in the schema (including onayla's 'don't set true unless the user asked'). The description restates the onayla rule rather than adding format or structure detail beyond it, matching the baseline 3.

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

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

States a concrete verb+resource: running arbitrary operations against App Store Connect and Google Play APIs. It implicitly differentiates itself from the typed siblings (appstore__*, play__*) as the generic dispatcher, but never says why an agent would choose this over a dedicated tool.

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

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

Explicitly tells the agent to resolve the operation name via magaza__endpoint_ara first, and states the precondition that mutating verbs (POST/PATCH/PUT/DELETE) require onayla=true. This is actionable when/when-not guidance tied to a named sibling.

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, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: it returns the operation's real name, parameters, and HTTP method, and its output feeds another tool. It does not mention result limits, caching, or failure modes, so it stops short of a 5.

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

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

Front-loaded with the core action, then the routing rule, the follow-up tool, and examples. Every sentence earns its place and nothing is padded.

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 no output schema, the description carries the burden of explaining returns and does so (operation name, parameters, HTTP method) plus the downstream workflow via magaza__cagir. It does not describe result ordering, how endpoint identity is keyed, or pagination, and the example-query language mismatch could mislead slightly.

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

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

Schema coverage is 100%, so the schema already documents sorgu/limit/magaza and sets the 3 baseline. The description adds sample queries ('subscription price', 'testflight tester', 'crash rate') that show how to shape a query, which is genuine extra value, though the Turkish example 'abonelik fiyat' sits in tension with the schema's instruction to search in API terms rather than Turkish.

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 precise verb+resource (searches endpoints across all App Store Connect and Google Play APIs) and its scope (both stores). It also positions itself in the toolchain by naming magaza__cagir as the executor of results, so an agent can distinguish it from the concrete appstore__*/play__* siblings without opening a schema.

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

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

Explicitly says when to reach for it ('if no ready-made tool does your job, use this first') and what to do next ('execute the result with magaza__cagir'). This is a clear when-to-use plus named-alternative pattern, leaving little to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds behavior annotations do not: it merges two separate stores into one list and aligns the same product across platforms, which is meaningful context about how the tool operates.

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, zero filler, and the core capability is front-loaded before the usage framing. Every clause carries information.

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

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

For a zero-param aggregation tool with no output schema, the description gives only a rough sense of the return (a merged list with paired entries) and says nothing about field structure, ordering, or volume. Adequate to call it correctly, but thin on what the agent will actually receive.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No misleading parameter claims are made.

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

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

States a concrete verb and resource (lists the apps across two stores in one list) and adds a differentiating behavior: pairing iOS/Android counterparts of the same product. An agent can distinguish this cross-store aggregation from the per-store siblings like appstore__uygulamalar and play__uygulamalar, though no sibling is named explicitly.

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

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

The closing line 'Nerede neyim var sorusunun tek çağrılık cevabı' frames the use case as a single-call overview, which is implied guidance. There is no explicit when-not or routing to alternatives such as magaza__abonelik_karsilastir or the per-store list 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavioral context by enumerating exactly what is checked (products live, priced in the requested country, subscription active) and noting the optional token verification. It stops short of describing what the diagnostic output looks like or any rate/scope limits, so it earns only a mid score against an already-covered annotation set.

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

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

Three sentences, front-loaded with the symptom this tool addresses, then the scope of the check, then the optional token path. Nothing is padded, though the middle sentence's colon-list is slightly dense and the closing sentence partly restates the schema's play_token description.

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 no output schema, the description carries the burden of explaining what the agent gets back, and it does not – it describes what is inspected but not the shape or content of the diagnostic result, which is the entire value of a diagnosis tool. The input side is fully covered by the schema and the usage trigger is present, so the gap is real but localized.

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 three parameters (ulke, uygulama, play_token) are already documented in the schema. The description reinforces the role of play_token as an optional addition but adds no format, syntax, or constraint detail beyond what the schema states, 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?

States a specific verb (teşhis eder / diagnoses) and a specific resource (the app's purchase setup across both stores), framed around a concrete symptom ('user paid but can't see premium'). This clearly distinguishes it from the sibling listing tools like play__urunler or appstore__iap_urunler, which enumerate rather than diagnose.

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 opening sentence gives a clear trigger condition – purchase-related complaints – which tells the agent when to reach for this tool. However, it never names the closest alternative (play__satin_alma_dogrula, which also verifies Play purchases) or states when not to use it, leaving the boundary between the two to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, and the description is consistent with a pure inspection tool. It adds the useful behavioral fact that the output is a body template to be applied to a later write, but says nothing about failure modes or what happens when 'operasyon' is unknown.

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, the key purpose front-loaded and the usage rule immediately after. No filler, nothing redundant.

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 no output schema and 0% parameter coverage, the description should at least point at how to discover a valid operation name and what the returned shape looks like. It covers the core idea but leaves those gaps for a two-parameter tool.

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

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

Schema description coverage is 0%, so the description carries the full burden, yet it never explains what 'operasyon' should contain or where to obtain a valid value (e.g. via magaza__endpoint_ara). Only the notion of 'magaza'/'operasyon' is loosely implied by the words in the sentence.

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

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

Names a specific verb+resource: it returns the expected request body shape for a given store operation. The purpose is clear and distinguishes it from the execution sibling (magaza__cagir) by framing it as a pre-call schema lookup, though it never names that sibling explicitly.

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

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

Gives explicit timing guidance: use it before POST/PATCH calls so the body is built correctly. It does not state exclusions (e.g. not needed for GET/DELETE) or name the companion tool that actually performs the call, so a small inference is left to the agent.

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, openWorldHint=true and destructiveHint=false, so safety is covered. The description adds genuinely useful behavioral context beyond that: it explains the 'diger_bolgeler' fallback applied to unlisted countries, which the agent could not infer from structured fields.

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

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

Two tight sentences with no filler, and the core purpose is front-loaded before the secondary fallback detail. 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 read-only tool with a fully documented schema, no output schema, and no nested objects, the description covers the main behavior plus the notable fallback rule. It lacks only explicit scope/collation details, which are minor here.

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 every parameter (ulke, plan_id, urun_id, paket_adi) is already documented in the schema. The description adds no parameter-level detail, so the 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 verb ('getirir') and resource (country-by-country prices for a Play subscription's base plan), which is concrete enough to distinguish it from the broader play__abonelikler listing tool. It does not explicitly name or contrast with any sibling, 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?

Usage context is only implied: the fallback behavior for unlisted countries hints at when the result set is complete, but there is no explicit when-to-use guidance or reference to alternatives like play__abonelikler or appstore__abonelik_fiyatlari. Nothing is misleading, but the routing guidance is thin.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered structurally. The description adds useful behavioral context by specifying the returned fields (duration, status, priced countries), but says nothing about pagination behavior despite a limit parameter, nor about auth requirements for a Play Console endpoint.

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

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

Two tight sentences with the purpose front-loaded and the return fields following. No filler or repetition, though it is short enough that it leaves little room for the routing information an agent would benefit from.

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?

There is no output schema, but the description compensates by enumerating what is returned (süre, durum, fiyatlandırılan ülkeler), and read-only annotations cover the mutation profile. The main gap is the absence of any routing guidance relative to the many subscription-related siblings.

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 three parameters (paket_adi, limit, arsivi_dahil_et) are already documented in the schema, which sets the baseline at 3. The description adds no parameter-level meaning beyond the schema, so it does not exceed the baseline.

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

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

States a specific verb (listeler) and resource (abonelikler ve temel planlar), and goes further by naming the returned fields (süre, durum, ülke). It partially distinguishes itself from the price-oriented sibling play__abonelik_fiyatlari, but does not name that sibling explicitly.

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

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

No guidance on when to use this versus play__abonelik_fiyatlari, appstore__abonelikler, or magaza__abonelik_karsilastir, all of which sit in the same domain. Usage is only implied by the phrase 'listeler', so the agent must guess at routing.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the useful fact that the data comes from Play Developer Reporting (an external source), consistent with openWorldHint, but says nothing about latency, freshness, or metric caveats.

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 compact sentences with the core action front-loaded and the motivating question second. No filler, though the second sentence is more sales pitch than operational detail.

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

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

For a read-only metric query with no output schema and fully documented parameters, the description plus annotations give the agent enough to call it correctly. It lacks any note on granularity or timezone handling for the day parameter, which is a minor gap.

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

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

Schema description coverage is 100%, so both parameters (paket_adi, gun with its default of 14) are already documented in the schema. The description adds no further meaning about these parameters, making the baseline 3 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?

It states a specific verb and resource ('Android vitals çökme oranını getirir') plus the data source (Play Developer Reporting), which clearly separates it from siblings like play__yorumlar or play__abonelikler. It does not explicitly name an alternative tool, so it stays 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 second sentence frames a use case ('why is my app crashing, since when has it increased'), which implies when to reach for this tool. There is no explicit when-not guidance and no alternative tool is named, so the guidance is only implied.

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 and destructiveHint=false, so the safety profile is covered. The description adds a genuinely valuable operational constraint not present in the annotations: Google only exposes the last 30 days, and older refunds are unavailable via the API. It does not mention pagination behavior tied to the limit parameter.

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 short sentences, each carrying distinct load: what it lists, why you'd call it, and the hard API limitation. Purpose is front-loaded with zero filler.

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

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

For a read-only list tool with annotations covering safety, the description supplies the key missing context (30-day window). With no output schema, return shape and pagination semantics remain unstated, but they are largely inferable from the limit parameter, leaving only a minor gap.

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 limit, paket_adi and sadece_urunler are already fully documented in the schema. The description adds no syntax, format, or default detail beyond that, 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 opens with a precise verb+resource: listing cancelled/refunded/revoked purchases, which is a distinct resource from siblings like play__satin_alma_dogrula (purchase verification) or play__abonelikler. An agent can tell exactly what this returns without opening the schema.

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

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

It gives a clear triggering context — 'to understand whether you need to revoke the user's access' — which tells the agent when this tool is the right choice. However, it names no alternative tool and states no when-not condition, so it falls short of full routing 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?

Goes well beyond the annotations: it discloses that Play exposes this data only inside an edit session, that the tool opens and closes the session without committing, that network POST+DELETE traffic occurs even though nothing changes, and that the service account needs version-management permission. This is exactly the kind of hidden side-effect and prerequisite an agent otherwise could not anticipate.

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

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

Front-loaded with the purpose, then the edit-session caveat. The note is dense but each clause is load-bearing (session behavior, side-effect profile, permission requirement). Slightly long but not padded.

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 what the tool returns (channel/version mapping and rollout percentage), the operational caveat, and the permission prerequisite, which is everything an agent needs for a single-parameter read tool with no output 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?

Only one parameter (paket_adi) and schema coverage is 100%, so the schema already carries the semantics including its example. The description adds no format or naming guidance beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource: lists the app's release channels (internal, alpha, beta, production) and the versions within each, plus rollout percentage. An agent can distinguish it from play__uygulamalar or the appstore__surumler sibling without opening a schema.

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

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

The description implies the context (auditing which version sits on which channel and to what audience share), but never states when to prefer it over siblings like play__uygulamalar or magaza__genel_bakis, and offers no exclusions. Usage is inferable rather than explicit.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safe-read and remote-lookup profile is covered structurally. The description adds that both subscription and one-time products are handled and that a status is returned, but says nothing about auth/permission requirements or rate limits beyond what annotations give.

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 short sentences, front-loaded with the core action before the framing question and the supported-scope note. No wasted filler, though the final sentence is somewhat redundant with the enum in 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?

A read-only verification tool with no output schema, so the description carries the burden of describing the returned status – yet 'durumunu döndürür' never says what status values or shape come back. Otherwise complete for a three-parameter call whose schema is fully documented.

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 all three parameters (tur, token, paket_adi) are documented in the schema, so the baseline is 3. The description only echoes the subscription-vs-product distinction that the `tur` enum already encodes, adding no format or syntax detail.

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

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

States a specific verb+resource ('satın alma token'ını doğrular' – verifies a purchase token) and the scope (subscription and one-time product). This distinguishes it from listing tools like play__abonelikler or play__urunler, though it never names a sibling explicitly, 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?

Gives an implied usage framing via the question it answers ('is this user's subscription really active?'), which helps an agent recognize the right moment. But it offers no when-not-to-use guidance or routing to alternatives such as magaza__iap_teshis or play__abonelikler, so usage is only implied.

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

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

Annotations already establish read-only, non-destructive, open-world behavior, so the bar is lower. The description adds real behavioral value by disclosing the dual-endpoint fallback (oneTimeProducts for migrated apps, inappproducts otherwise) and that the tool reports which endpoint succeeded, which helps an agent interpret results.

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 followed by the relevant behavioral nuance about endpoint selection. Nothing is redundant or padded.

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 read-only, single-parameter listing tool with no output schema, the description covers what the tool returns at a high level (product listing) and explains the fallback behavior. It could go further on result shape or error handling, but the essentials are present.

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?

There is a single parameter and schema coverage is 100%, so the schema already documents 'paket_adi' with an example. The description adds no parameter-level detail, which is the expected baseline 3 when the schema does the work.

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

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

States a specific verb and resource: 'lists one-time in-app products' ('Tek seferlik uygulama içi ürünleri listeler'). The qualifier 'tek seferlik' cleanly separates it from the subscription-oriented siblings like play__abonelikler and appstore__abonelikler.

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?

Usage is implied by the resource scope (one-time products), but the description never says when to choose it over alternatives such as play__abonelikler or magaza__iap_teshis, nor are prerequisites or exclusions stated. Adequate but leaves routing to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds genuine context beyond them: the data source (Play Developer Reporting API) and the reason (Android Publisher API has no listing endpoint), plus the auth scoping to the service account. It doesn't cover pagination or truncated-result behavior, so not a 5.

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 short sentences, front-loaded with the core action, then the usage pointer, then the caveat. No wasted text and every sentence carries distinct 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?

For a simple read-only list tool with annotations covering the safety profile and 100% schema coverage, the description is nearly complete and even explains what the returned package names are for (feeding other tools). Minor gap: no return-format or volume expectation, though no output schema exists to carry it.

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 single 'limit' parameter (default 50, max 1000) is fully documented in the schema. The description adds nothing about parameters; baseline 3 applies.

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

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

States a specific verb (listeler) and resource (Google Play uygulamaları) scoped to the service account's access, which distinguishes it from the operation-specific play__ siblings. An agent immediately knows this is the discovery/enumeration tool.

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

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

Explicitly routes usage: 'Diğer play__ araçlarının istediği paket adını (packageName) buradan al' tells the agent this is the prerequisite call for other tools. There is no alternative for listing Play apps, so no exclusion is needed, though it doesn't state a 'when not to use'.

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 and openWorldHint=true, so safety is covered. The description adds genuinely useful behavior beyond them: the API's ~1-week data window and the export fallback. It omits pagination and rate-limit behavior, but the freshness caveat is a meaningful addition.

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 with zero waste. The core purpose leads, and the data-limitation caveat follows immediately, so the most decision-relevant fact is front-loaded rather than buried.

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 read-only, open-world tool with full schema coverage and no output schema, the description covers the one non-obvious constraint an agent must know. Return shape and pagination are left implicit, but nothing critical to correct invocation 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% with three well-documented parameters (dil, limit, paket_adi), so the schema carries parameter meaning. The description adds no syntax, default, or format detail beyond it, which is the expected baseline when coverage is complete.

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

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

States a specific verb and resource ('Google Play kullanıcı yorumlarını getirir'), so the agent knows this retrieves Play reviews rather than App Store reviews. It does not explicitly contrast itself with the sibling play__yorum_yanitla (reply), though the verb alone implies the read-only distinction.

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

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

Gives a clear situational constraint: Play only exposes roughly the last week of reviews via API, and older data requires Play Console export. That tells the agent when this tool is insufficient, but it does not name the sibling tools or state positive invocation 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds the crucial specifics: the reply is publicly visible and cannot be undone, and it silently refuses to run without onayla=true. That is meaningful risk detail beyond the structured hints, though it stops short of describing auth scopes or error 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?

Two tight sentences: purpose first, then the risk and the confirmation gate. Nothing is padded and the most consequential fact (irreversible, public) is front-loaded after the action.

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 4-param mutation with no output schema and clear annotations, the description covers action, publicity, irreversibility, and the confirmation gate. It lacks only ancillary details (which review states accept replies, what happens on invalid yorum_id), which are minor for this scope.

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 all four parameters (including the 350-char limit, the yorum_id source, and the confirmation gate) are already documented in the schema. The description restates the onayla requirement without adding format or constraint detail beyond it, so 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?

States a specific verb and resource: writing a developer reply to a Google Play review. Combined with the sibling list, an agent can distinguish it from play__yorumlar (reading reviews) and appstore__yorum_yanitla (the App Store equivalent) by platform and action.

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

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

Gives a real prerequisite ('onayla=true verilmeden çalışmaz') but no when-to-use vs alternatives, no indication of which reviews are valid targets, and no mention of rate limits or eligibility. The gating condition is useful but not a full usage policy.

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