Tester Exchange

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the content scope (platform, credits, actions), which is mild but real context; it says nothing about return format, freshness, or rate limits.

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 covering three content areas with no filler or repetition. Nothing could be removed without losing 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 no-argument, read-only informational tool with no output schema, the description adequately tells the agent what knowledge it will get back. It could be more complete by clarifying its relationship to pricing and platform_stats, but nothing essential to invoking it 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. Schema coverage is 100% and additionalProperties is false, leaving no parameter gaps.

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 the resource (Tester Exchange overview) and enumerates the content it returns: what the platform is, how credits work, and the available actions. That is specific enough to distinguish it from action tools like add_app or buy_credits_links, though it never explicitly contrasts itself with siblings such as pricing or platform_stats.

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 statement of when to call this versus alternatives like pricing or platform_stats, nor any prerequisites or exclusions. Usage is only weakly implied by the content list; an agent must guess that this is an onboarding/help entry point.

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 a non-read-only, closed-world operation. The description adds genuine context beyond them: an auth requirement ("needs a token") and a required precondition (track must be published). It says nothing about failure modes, idempotency, or what happens if the app is already added — relevant gaps for a mutation.

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 fragments, front-loaded with the core action and followed by prerequisite and auth notes. The parenthetical asides are efficient, though the opening verb choice wastes the most valuable position in 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?

A five-parameter mutation with no output schema and only partial schema descriptions needs more than three fragments. Return behavior, duplicate-handling, and the meaning of the optional fields are all unaddressed, leaving an agent to guess at the call's effects.

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 only 60%, so the description carries real burden here, and it names none of the five parameters. It doesn't clarify the distinction between name, description, and instructions, or when group_url applies. The one useful semantic — that the target app must be on a published closed track — constrains package_name only indirectly.

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 verb "List" is misleading for what is clearly a write/registration operation (annotations confirm readOnlyHint=false), and the object is ambiguous — it never says what the app is being listed *in*. It does convey the domain (Android app in Google Play closed testing) and hints at the sibling get_testers, so the purpose is inferable but not stated crisply.

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 routes the agent toward an alternative by noting "get_testers does this for you" and states a real precondition (the closed track must be published). What's missing is an explicit statement of when a human would choose this manual path over get_testers, but the context is clear enough.

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 this is a mutation (readOnlyHint=false) in a closed world, so the safety profile is covered. The description adds two real behavioral facts beyond the annotations: a per-unit cost of 15 credits and a token requirement. It omits whether slot purchases are reversible, whether count is capped, or what happens to an already-live campaign.

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 two compact parentheticals for cost and auth. Nothing is padded and the core action leads. The parentheticals are terse but each carries real 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 low-complexity two-parameter mutation tool with annotations covering safety, the description is adequate but leaves the undocumented count parameter and the return/confirmation behavior unexplained. Cost and auth are covered, which is more than most, but the gap on count is notable given the 50% schema coverage.

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 only 50%: package_name is documented in the schema, but 'count' has no description anywhere. The description does not compensate, saying nothing about what count controls, its default of 1, or any upper bound. Only the plural 'slots' loosely hints that count exists.

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 ('Add tester slots to a live campaign') with an added cost qualifier that narrows intent. An agent can distinguish it from siblings like add_app or start_campaign. It stops short of naming any sibling explicitly, so it is clear but not fully differentiated.

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

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

The phrase 'live campaign' implies the precondition that the campaign must already be running, and '(needs a token)' signals an auth prerequisite. However, there is no explicit when-to-use versus when-not guidance and no alternatives named among the many campaign-related siblings.

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

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

Beyond the readOnlyHint/openWorldHint annotations, the description adds two useful behavioral facts: the call only produces links and a human must finish payment, and a token is required. That is real added context for an agent deciding whether the call will actually complete a purchase.

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 fragments with no filler, and the core purpose is front-loaded. The parenthetical auth note is slightly awkward but costs little.

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 no-parameter, no-output-schema read tool whose annotations already cover the safety profile, the description covers purpose, the human-in-the-loop constraint, and auth. Only details like link count or validity would add more.

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?

With zero parameters and 100% schema coverage, there is no parameter surface to document, so the baseline of 4 applies. The description adds nothing parameter-related, but nothing is missing either.

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 identifies the resource (checkout links for credit packs) clearly enough that an agent understands the tool returns payment links rather than performing a purchase. It does not distinguish itself from the similar-looking 'pricing' 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 is only implied: 'A human must complete the payment' tells the agent this is for handing off a link, but there is no explicit when-to-use guidance or naming of alternatives such as 'pricing'. 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 openWorldHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral fact – that a token is required – but says nothing about rate limits, freshness of the daily/tester metrics, or what a caller must prepare beyond the token.

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 efficient sentence, front-loaded with the report contents and appending the token requirement as a short parenthetical. Nothing is padded, though the noun-phrase form is slightly less actionable than a verb-led sentence.

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 hinting at return content, and listing the metrics does partially satisfy that. However, it omits how the report is structured, time-range behavior, and any noted prerequisite beyond the token, leaving modest gaps for a metrics 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 the single package_name parameter is fully documented in the schema, so baseline is 3. The description adds no extra meaning about which package or how it scopes the report.

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 the specific data the tool returns – testers, daily active testers, feedback, and production-access evidence – which lets an agent tell it apart from siblings like list_open_tests or my_tests. It lacks an explicit verb (e.g. 'retrieve/generate report'), but the resource and scope are clear.

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

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

Beyond the parenthetical '(needs a token)', there is no guidance on when to call this versus alternatives such as list_open_tests, my_tests, or platform_stats. No conditions, prerequisites, or exclusions are stated, leaving the agent to infer usage.

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 flag a non-read-only, closed-world operation. The description usefully adds the key behavioral facts beyond that: it spends credits, the cost is 15 per seat, and charging applies only to seats not filled by friends/circle. However, it omits what happens on insufficient credits, whether the action is reversible, and what the 'token' requirement actually entails.

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 short but front-loads the billing consequence instead of the action, and the parenthetical '(needs a token)' is cryptic and likely to confuse rather than help. It is not padded, but its ordering and jargon reduce clarity.

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 money-spending mutation with a single fully-described parameter and no output schema, the description covers the most important risk (credit cost and conditional charging) but leaves significant gaps: what the token is, prerequisites like having a campaign or swap-circle membership, and failure/response behavior. Adequate but with clear gaps.

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 one parameter and schema description coverage is 100% (package_name is documented as an Android package name with an example), so the schema carries the parameter semantics. The description adds nothing about the parameter, which matches the baseline 3 for a fully documented single-parameter 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 implies it fills test seats from an exchange and charges credits for unfilled seats, but the phrasing is jargon-heavy ('friends', 'the circle', 'exchange testers') and leads with the billing mechanic rather than a clean verb+resource statement. It does implicitly differentiate from add_testers by charging only for seats friends/circle don't fill, but an agent must already understand the swap-circle model to parse 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?

No explicit when-to-use or when-not-to-use guidance relative to siblings like join_swap_circle, start_friends_test, or add_testers. The only prerequisite hint is the opaque '(needs a token)', with no explanation of what token, where it comes from, or what happens if absent.

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=false, and the description adds genuinely useful behavior: that it requires a token and that the response covers seat occupants, seats remaining, exchange cost, and a share link. That compensates for the absence of an output schema; it stops short of noting failure modes or whether costs are estimates.

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 the most valuable information (what fills the seats, seats left, cost, share link) front-loaded, plus a short parenthetical for the token requirement. Nothing wasted, though the parenthetical reads as an afterthought.

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

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

For a single-parameter read tool with no output schema, the description does the necessary work by enumerating the return contents and flagging the token requirement. It could be slightly stronger by clarifying how this differs from the other status/list siblings, but nothing essential 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 coverage is 100% with a concrete example (com.example.app), so the schema already carries the parameter meaning. The description only reinforces the scope ('one of the user's apps'), which is marginal added value over the schema — 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 names a specific resource (the 12 seats of one of the user's apps) and enumerates what it returns: seat occupants, remaining seats, exchange cost, and share link. That is far more concrete than a bare 'status' restatement, though it doesn't explicitly distinguish itself from siblings like swap_circle_status or my_swap_circle.

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 statement of when to use this versus swap_circle_status, my_swap_circle, or my_tests; the agent must infer from the 'friends, swap circle, exchange testers' parenthetical that this covers a single package's seat view. It does hint that a token is required, but that is auth context rather than usage 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?

Beyond the annotations (which only say not read-only and closed-world), the description discloses real side effects: it may create an app, start a test, and consume spare credits, and it declares itself idempotent ("safe to call again"). It also flags the auth requirement ("needs a token") and separates automated steps from the ones only a human can complete, which is exactly the context an agent needs to avoid promising a finished result.

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 most actionable signal ("START HERE", one call, 12 testers) is front-loaded and the remaining sentences explain side effects, human steps and idempotency. The embedded parenthetical about paying versus earning is dense and slightly promotional, but it earns its place as a branch instruction.

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 takes on the return-value burden and does so: it says the call returns progress plus the human-only steps and payment links. Auth, idempotency, credit consumption and the manual Play Console/Google Group action are all covered, so an agent can call it and set expectations correctly.

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

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

Schema coverage is 100% and both parameters are documented there, so the description adds little per-parameter meaning. It only implies that package_name identifies the target app while name is a label; no format or fallback behavior is added. Baseline 3 applies when the schema carries the parameter load.

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?

"One call gets an Android app its 12 Google Play closed-testing testers" states a concrete outcome, and the description then enumerates the orchestration behind it (adds the app, opens its test, applies spare credits, returns progress). "START HERE" plus the explicit mention of credit links and the free alternative distinguishes it from siblings like add_testers, add_app and start_friends_test.

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?

"START HERE" and "safe to call again any time to check progress" give clear entry-point and re-invocation guidance, and the credit-vs-earn branch points to the alternative path. It does not explicitly say when to prefer add_testers or start_friends_test instead, so the routing against those siblings is left partly 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds meaningful context by stating that a token is required and by enumerating the account data returned.

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?

It is a single front-loaded sentence plus a short parenthetical. There is no filler, and the returned resources are listed before the optional auth note.

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

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

For a zero-parameter read-only account summary, it explains what data is returned and that authentication is needed. It could clarify what 'open tests' means relative to my_tests, but the core context is 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?

The tool has zero parameters and an empty schema, so the baseline is 4. The description correctly does not introduce parameter details that do not exist.

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 three concrete data items returned: credit balance, invite link, and open tests. This is specific enough to identify an account-summary tool, though it lacks an explicit verb and does not differentiate itself from siblings like my_tests or about.

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 only guidance is the prerequisite '(needs a token)'. It gives no indication of when to call this tool instead of my_tests, my_apps, or about, leaving usage selection to inference from the name.

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

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

Annotations already cover the safety profile (readOnlyHint=true, openWorldHint=false), so the bar is lower, and the description still adds the authentication requirement '(needs a token)' plus the fact that status is live/current and what dimensions it exposes. It stops short of 5 by not saying anything about ordering, volume, or how an app with no campaign is represented.

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?

One front-loaded sentence plus a short auth parenthetical, with the resource first and the clarifying field names second. No filler or restatement of the tool name.

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 parameters, a trivially simple schema, and no output schema, the description carries the return-value burden and mostly discharges it by enumerating the status fields. It would be fully complete if it clarified the per-app grouping and what 'open slots' means in practice.

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 and the schema is fully covered, so there is nothing for the description to compensate for; the baseline for a no-parameter tool 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 the resource (the user's apps) and the payload (live status of each testing campaign, with the specific fields active testers, waiting installs, open slots), so an agent knows exactly what it retrieves. The verb is only implied ('my apps' = list my apps) and nothing distinguishes it from siblings like my_tests, my_account, or my_swap_circle, which is why 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?

There is no when-to-use statement, no prerequisite framing beyond the token note, and no mention of alternatives. With 19 siblings, several of which sound like overlapping 'my X' listing tools, the absence of any routing guidance is a real gap.

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=false, so the safety profile is covered. The description adds two pieces of real value beyond that: the token/auth requirement and a hint at what is returned (verified days and credits earned), but says nothing about format, ordering, or pagination.

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?

It is a single short sentence with no padding, which is good, but it is a sentence fragment with the auth note wedged in trailing parentheses. Brevity here reflects under-specification rather than disciplined conciseness.

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 no-parameter read tool with no output schema, the description is minimally sufficient: annotations carry the safety profile and the text names the resource and return contents. It still leaves the core ambiguity (how this differs from list_open_tests) and the return shape unresolved.

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 per the rubric the baseline is 4. There are no parameter semantics for the description to clarify or for it to omit.

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 the resource (the user's own tests as a tester, with verified days and credits) but uses a fragment with no real verb — an agent can't tell whether this lists, summarizes, or reports on tests. It loosely implies a 'my tests' scope versus the sibling list_open_tests, but the differentiation is left to inference rather than stated.

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, no when-not-to-use, and no mention of siblings such as list_open_tests, my_apps, or campaign_report. The only guidance is the parenthetical '(needs a token)', which is an auth prerequisite rather than usage 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 and openWorldHint=false, so safety is covered. The description adds meaningful context beyond that: the numbers are 'live' (i.e., refreshed/real-time rather than cached) and it enumerates the returned fields, which matters because there is no output 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?

A single front-loaded sentence listing the metric set with no filler. 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 no parameters, no output schema, and read-only annotations, the description carries the return-value burden and does so adequately by naming the four metric groups. A one-clause note on freshness or scope 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. No misleading parameter hints are given.

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 resource (live platform numbers) and enumerates exactly which metrics are returned, which lets an agent distinguish it from siblings like about, pricing, or my_account. It does not, however, explicitly contrast itself with the overlapping 'about' 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?

There is no guidance on when to call this versus 'about', 'pricing', or 'my_account', all of which could plausibly surface platform-level information. Usage is only implied by the noun 'platform numbers'.

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=false, so the safety profile is covered structurally. The description adds only that the content spans both earning/spending mechanics and pack prices, with no mention of freshness, account-specificity, or response shape. It adds context but not much.

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 eleven-word sentence with the substantive content ('how credits are earned and spent') front-loaded ahead of the narrower 'credit pack prices'. Nothing is wasted and nothing important is 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 zero-parameter, read-only info tool with no output schema, the description covers the subject matter adequately. It could note whether the figures are global or account-specific, but the gap is minor.

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 no parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No misleading hints about inputs are given.

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 the resource precisely: credit earning/spending rules plus credit pack prices. That is enough for an agent to know this is a static informational lookup rather than an account or purchase tool. It stops short of distinguishing itself from the nearby 'about', 'my_account', and 'buy_credits_links' 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?

There is no when-to-use or when-not-to-use guidance. With siblings like 'about', 'my_account', and 'buy_credits_links' plausibly competing for the same credit/pricing questions, the description leaves the agent to guess which one answers a pricing query.

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 indicate this is a non-read-only operation; the description adds important behavioral context by stating that closing returns unused credits to the user's balance and that a token is required. It does not cover reversibility or confirmation requirements, so it is strong but not complete.

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, front-loads the core action, and every sentence adds value: operations, side effect, and auth requirement.

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 mutation tool with annotations and no output schema, it covers the core action and key side effect. Gaps remain around where the token must be supplied and whether closing is irreversible or requires confirmation.

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 50%: package_name is documented in the schema, while status has only an enum. The description adds useful intent-level meaning by mapping pause/resume/close to the status options, but it does not further explain package_name or token handling.

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 specific verbs and a clear resource: pause, resume, or close a campaign. It does not explicitly differentiate itself from sibling tools such as start_campaign, but the action is still easy to identify.

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 status operations imply usage on an existing campaign, and the token requirement is noted. However, there is no explicit guidance on when to use this instead of start_campaign or other campaign tools, and no exclusions are stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the auth requirement '(needs a token)', which is useful context beyond the annotations, but says nothing about rate limits, what the generated URLs look like, or whether the public page is persisted.

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 compact sentence that lists the deliverable assets first and the auth caveat last. It is appropriately sized, though the opening noun phrase makes the action slightly less front-loaded than a verb-first statement would be.

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 tool the description is roughly adequate: it tells the agent what the tool returns. It lacks any usage context and does not clarify the relationship to sibling app-management tools, leaving a moderate gap for an agent choosing between them.

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

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

Schema coverage is 100% and the single package_name parameter is documented in the schema itself. The description only references 'one of the user's apps' without adding format or constraint details 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?

The description names the artifacts produced (public 'help test my app' page, ready message, README badge) and scopes them to one of the user's apps, so the output is inferable. However, it is a noun-phrase list rather than a clear verb+resource, and it does not distinguish itself from siblings like my_apps or add_testers beyond the asset types.

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 statement of when to use this tool versus alternatives, nor when not to. The only usage-adjacent information is the parenthetical '(needs a token)', which is a prerequisite rather than selection 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?

Annotations only say it is a non-read-only, closed-world operation; the description adds the real behavior an agent needs: pricing (testers x 15 credits), escrow hold, and that unused credits are returned to the balance in credits rather than money. It does not cover what happens on failure, duplicate campaigns, or cancellation/refund effects, which keeps it from 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?

Two tight sentences with zero filler; the core action comes first and cost/escrow follows. '(needs a token)' is terse to the point of being cryptic, but it earns its place as an auth warning.

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 mutating tool with no output schema, the description covers cost, escrow, refund, and auth well, but omits what the call returns (e.g., a campaign identifier an agent would need for campaign_report or set_campaign_status), leaving a meaningful 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 coverage is 50%: package_name is documented in the schema, while testers has only default/min/max constraints. The description adds genuinely new meaning by tying testers to a cost formula, but never mentions the default of 15, the 12-30 range, or that package_name must belong to the user's own app.

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: 'Start recruiting a set number of testers for one of the user's apps.' It is distinguishable from set_campaign_status and start_friends_test by the recruiting-plus-cost framing, though it never names 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?

Implies usage ('start recruiting') and hints at a prerequisite with '(needs a token)', but gives no guidance on when to choose this over start_friends_test, add_testers, or set_campaign_status, and no exclusions or preconditions beyond auth.

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 only mark this as non-read-only and closed-world, so the description carries useful extra load: it discloses that a token is required, that the call returns the share link plus a ready message, and that participants must open the app once a day at testerexchange.com/earn. It stops short of saying whether an existing test would be replaced or what error conditions look like.

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 tight sentences, front-loaded with the key qualifier 'Free:' and closing with the '(needs a token)' prerequisite. Nothing is redundant, though the trailing parenthetical makes the prerequisite easy to skim past.

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

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

For a single-parameter, no-output-schema tool, the description covers the cost model, the token prerequisite, and what comes back (link plus ready message), which is the information an agent needs to call it correctly. The only gap is behavior on repeat invocation for the same package.

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 package_name parameter is already documented with an example format in the schema. The description adds only that the app must belong to the user ('one of the user's apps'), so the schema does the substantive work and baseline 3 applies.

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

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

The description opens with a specific verb and resource: 'open a test for one of the user's apps' so friends and family can join from the share link. That is clearly distinct from siblings like start_campaign or fill_from_exchange, though the description never names the alternative by name, which is why this 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?

The leading 'Free:' signals this is the no-cost path versus paid campaign tools, and 'so friends and family can join' implies the target audience. However, it never explicitly states when to choose this over start_campaign or fill_from_exchange, leaving the agent to infer the contrast.

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