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

No annotations are provided, so the description carries the full burden. It discloses the key mode-switch behavior based on parameter presence, but omits what read returns, whether write overwrites existing clipboard content, and any permission or platform constraints.

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

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

One compact sentence, front-loaded with the resource and the read/write rule; no redundant wording.

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 tool, the description covers the core invocation logic. However, with no output schema and no annotations, it should state the return value of a read and the effect of a write to be fully complete.

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

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

Schema coverage is 0% and the single optional 'text' parameter is undocumented in the schema. The description compensates by explaining that supplying text triggers write mode, but does not describe the content format or limits.

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 the specific resource (phone clipboard) and the two operations (read/write) with the exact condition that selects each. No sibling tool overlaps, so differentiation is implicit but clear.

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

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

The conditional 'without text = read, with text = write' tells an agent how to invoke each mode, but there is no explicit guidance on when to prefer this over shell or other siblings, nor any prerequisites.

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

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

With no annotations, the description must carry the behavioral burden. It discloses the return format (package names) and that filtering is a partial-name match, which is useful, but it omits whether matching is case-insensitive, whether it is substring or prefix, and whether results are paginated or ordered.

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

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

Two short sentences, front-loaded with the core action and followed by the parameter hint. No wasted wording.

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 optional-parameter read tool with no output schema, the description covers what it returns and how to filter. Only the precise matching behavior is left unspecified, 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 coverage is 0%, so the description must compensate, and it does: it defines filter as 'part of the name' and gives two concrete examples. The only gap is the exact matching semantics (case sensitivity, substring vs prefix).

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 ('List installed apps') and clarifies the return value is package names, which distinguishes it from the sibling open_app. It stops short of explicitly naming alternatives, but the intent is unambiguous.

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

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

The filter example ('tele' or 'spotify') implies how to narrow results, but there is no explicit when-to-use guidance, no statement about omitting the filter to list everything, and no reference to sibling tools like open_app.

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

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

With no annotations present, the description carries the full burden, and it does disclose the return shape and units (accuracy in meters) plus that location can come from GPS or network. It says nothing about permission requirements, whether the call blocks until a fix is available, what happens on timeout or when no signal exists, or whether the reading is cached/stale.

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 front-loads the resource and then enumerates the returned values, with no filler. 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 zero-required-parameter, read-only sensor tool with no output schema, the description covers what is returned and in what units, which is the core need. It falls short on operational context an agent needs in practice: permissions, latency/blocking behavior, and failure modes when no fix is available.

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

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

Schema coverage is 100%, so the baseline is 3, and the description adds real meaning by explaining that location can come from GPS or network, which contextualizes the provider parameter and its tradeoffs. However, it omits the 'passive' provider option that the enum exposes, leaving that choice unexplained.

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 (current phone location) and the fields returned (latitude, longitude, accuracy in meters), so an agent knows exactly what it gets back. It does not reference any sibling, but none of the listed siblings (shell, phone_status, clipboard, etc.) overlaps with location, so differentiation is not needed.

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 only: the word 'current' suggests a one-shot read of the present fix, and the parenthetical GPS/network hints at source selection. There is no explicit when-to-use statement, no guidance on choosing among provider values, and no mention of when not to call it (e.g. permission not granted).

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the Termux:API dependency, but omits permissions, failure behavior, notification persistence, and any return or confirmation details.

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 wasted words. The prerequisite is compactly parenthesized and does not obscure the main 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 simple two-parameter notification tool, the description covers the core action and the key app dependency. However, it leaves parameter roles and error/return behavior undocumented, which is a meaningful gap given no annotations or 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?

Schema description coverage is 0%, and the description does not explain the required "text" parameter or the optional "title" parameter. It adds no meaning beyond the bare property names.

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, "Show," and resource, "notification on the phone," so the action is clear. It does not explicitly differentiate itself from siblings such as speak or clipboard, 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?

The only guidance is the prerequisite that the Termux:API app is needed. There is no explanation of when to use this tool instead of siblings like speak, clipboard, or open_url, and no when-not 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?

No annotations are supplied, so the description carries the full behavioral burden, and it only covers the happy path. It says nothing about failure behavior for an invalid or uninstalled package, whether the app is brought to the foreground, or whether the call blocks until launch completes. For a simple, largely self-evident action tool this is adequate but clearly incomplete.

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 padding: the action and its argument format come first, and the alternative/derivation hint comes second in the natural reading order.

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, non-annotated action tool with no output schema, the definition covers purpose, argument format, and prerequisite discovery. The remaining gap is error/edge-case behavior, which matters but is minor given the tool's simplicity.

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

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

The schema declares only an untyped string with 0% description coverage, so the description's reverse-DNS example is the sole source of format guidance and adds real value. It doesn't state whether the identifier is case-sensitive or what constitutes an invalid value, keeping it short of a 5.

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 ('Open') and resource ('an app'), scoped by package name, and includes a concrete example identifier (org.telegram.messenger). It also names the sibling used for discovery, so an agent can tell it apart from list_apps or open_url without opening any 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 routes the agent to list_apps when the package name is unknown, which is the main prerequisite. It doesn't contrast against open_url (URLs vs. packages) or state what to do if the package isn't installed, but the primary when-to-use path is clear.

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

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

With no annotations supplied, the description carries the full behavioral burden. It does disclose one genuinely useful trait beyond the schema — that the URL may be handed off to a matching app rather than always opening in a browser — but says nothing about foreground/background behavior, permission prompts, failure modes, or whether the call blocks.

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 parenthetical is the one piece of clarifying detail that earns its place.

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

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

The tool is simple enough (one string parameter, no output schema) that a one-liner is close to adequate. But with no annotations and no output schema, the description should still cover what a successful call looks like and how bad input or app-routing failure surfaces, which it omits.

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% for the single parameter, so the description must compensate and does not. It never says whether 'url' requires an https:// scheme, whether custom app schemes (e.g. youtube://) are accepted, or how URLs are matched to apps — all of which matter for the only input.

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 ('Open a URL on the phone') and clarifies the routing behavior — browser or a matching app such as YouTube. It is distinguishable from open_app by operating on a URL rather than an installed app, 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?

No guidance on when to prefer this over open_app (e.g. deep links vs app launch) or over shell. There is also no guidance on URL format, required scheme, or what happens on an invalid or unsupported URL, leaving the agent to infer everything about selection.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the categories of information returned, which signals a read-only status operation, but it does not explicitly state that the tool is non-destructive, requires no permissions, or has no side effects.

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

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

The description is a single, front-loaded sentence that lists the relevant status categories without any wasted wording. It is appropriately sized for a zero-parameter status 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?

Given the low complexity, zero parameters, and absence of an output schema, the description provides a reasonably complete picture of what the tool returns. It could be slightly more complete by specifying the format or granularity of Wi-Fi and volume data, but the core categories are covered.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and it appropriately focuses on the returned status categories instead.

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, phone status, and enumerates the status categories returned: battery level, charging state, temperature, Wi-Fi connection, and volume. It is clearly distinguishable from the sibling action tools such as open_app, notify, and speak, though it does not explicitly contrast itself with them.

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

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

The description implies usage by naming status categories, but it gives no explicit guidance on when to call this tool versus alternatives. There are no exclusions, prerequisites, or conditions that would help an agent choose it over another status-related 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?

No annotations, so the description carries the full burden. It does disclose genuinely useful behavior: the working directory is the Termux home, shared storage lives at ~/storage/shared and requires termux-setup-storage first, and specific command families are available. It says nothing about output format (stdout/stderr/exit code), timeout enforcement despite the 60000ms default, or that arbitrary command execution is inherently destructive.

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, and the core action is front-loaded before the environment details. The parenthetical prerequisite (after termux-setup-storage) 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 an arbitrary-code-execution tool with no annotations and no output schema, the environment context (cwd, storage, available binaries) is the hardest thing for an agent to infer and is well covered. What is missing is consequential: return value shape, failure/exit-code behavior, and any safety framing about running destructive commands.

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%: timeout_ms is documented in the schema as defaulting to 60000, while command has no schema description at all. The description partially compensates by establishing the working directory and storage paths, which determine how relative paths in command resolve, but it adds nothing about command syntax, quoting, or what happens when timeout_ms is exceeded.

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: run an sh command in Termux on the user's Android phone. That clearly separates it from the task-specific siblings (open_app, notify, clipboard), though it never explicitly says to prefer those wrappers over raw shell.

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 by the environment facts: the mention of pkg, termux-*, am and pm hints at what is possible here, but there is no explicit 'use this when...' or 'prefer open_app over am start' guidance, and no statement about when shell is the wrong choice.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It discloses only the output modality (audio TTS on the phone); it says nothing about whether the call blocks until speech finishes, whether it requires an active phone connection, or what happens on failure.

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 short sentence with the key mechanism front-loaded and no wasted words. It is efficient, though its brevity is part of why behavioral and parameter detail is missing.

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 tool with no output schema, the description is minimally adequate to identify the action. However, with no annotations and an undocumented required parameter, an agent lacks enough context about side effects and defaults to invoke it confidently.

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%: 'language' has an example list but 'text' is undocumented. The description adds no meaning to either parameter, such as length limits, expected format, or what happens when language is omitted (default voice?).

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 specific verb ('Speak') and resource ('text out loud on the phone') and clarifies the mechanism with '(TTS)'. It does not distinguish itself from siblings such as notify, which could plausibly also emit user-facing output, 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 guidance on when to use this tool versus alternatives like notify, nor any stated preconditions (e.g. phone connected, audio available). The agent must infer usage entirely from the one-line purpose.

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