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

No annotations are provided, so the description carries the full burden. The verb 'Get' clearly indicates a read-only operation, and the listed fields imply no side effects. However, it does not mention prerequisites like device connectivity or potential performance implications, which are minor gaps for a getter tool.

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 key details with no fluff. Every word contributes to conveying the tool's purpose and output, making it highly concise and well-structured.

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

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

The tool has only 2 parameters and no output schema. The description lists the expected output fields, which is helpful, but it fails to explain the parameters' semantics or any conditions for use. Given the small complexity, it is adequate but leaves room for improvement, especially regarding 'device_id' and device prerequisites.

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 description does not mention any parameters. The required 'package_name' is inferable from the tool name, but the optional 'device_id' is left unexplained. The description adds no value beyond the schema, which already lists the parameter names and types.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('app details'), listing concrete fields (version, dates, SDK, permissions, data size). This distinguishes it from sibling tools like quest_app_list (lists apps) and quest_app_memory (memory info).

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 when detailed app information is needed rather than just a list of apps, but it does not explicitly mention alternatives or conditions for use. No comparison to sibling tools is provided, so it offers only implicit guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses the default filter behavior and allowed filter values, which is useful. However, it does not mention any permissions, side effects, or return format, leaving the read-only nature to be inferred from the word 'list' rather than stated.

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 extremely concise, consisting of two short sentences. Information is front-loaded: the core purpose comes first, followed by parameter details. Every word adds value, with no filler or redundancy.

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

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

For a simple 2-parameter listing tool, the description covers the essential behavior and filter options. The missing explanation of device_id is a minor gap, but the overall context (Quest app listing) makes the tool's function clear. The lack of output schema is mitigated by the simple nature of the operation, though a bit more detail on return format would be helpful.

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 description explains the 'filter' parameter with its default value and valid options, adding meaning beyond the bare schema. However, the 'device_id' parameter is not mentioned at all, and with 0% schema description coverage, the description should compensate for both parameters. It partially does, but the gap for device_id prevents a higher score.

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

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

The description clearly states the tool's purpose: 'List installed apps.' It uses a specific verb and resource, and the filter options (sideloaded, system, all) further clarify the scope. This distinguishes it from siblings like quest_app_info, which presumably targets a single app, and quest_install/quest_uninstall.

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

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

The description provides useful context on the filter parameter, including the default value and allowed options, which implies when to use the tool (e.g., to list only sideloaded apps). However, it does not explicitly mention alternatives or when not to use this tool, so usage guidance remains implicit 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?

No annotations are present, so the description carries the burden. It clearly describes the output content (PSS components in KB) and adds insight about graphics allocations, but does not disclose whether this is a one-time sample, if the app must be running, or any prerequisites.

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, focused sentence that front-loads the purpose ('Get an app's memory anatomy') and packs additional useful context without waste.

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 the tool's core purpose and output content well, and the lack of output schema reduces the need to describe return values. However, missing parameter explanation and no mention of invocation context are minor gaps for such a simple 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% and the description does not explain either parameter. The agent must infer that package_name is the app's package and device_id selects the device; the description adds no parameter value beyond the schema field 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?

The description uses a specific verb ('Get') with a clear resource ('an app's memory anatomy') and specifies exact metrics (PSS in KB) and components (java heap, native heap, code, stack, graphics). It distinguishes itself from broader sibling tools like quest_performance or quest_app_info.

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

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

The description implies usage for diagnosing memory exhaustion, especially graphics-related issues in VR apps ('graphics allocations... are usually what exhausts memory in VR apps'), but does not explicitly state when to prefer this tool over alternatives or provide 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?

The description discloses that the tool resets an app to freshly-installed state and mentions specific data types (saves, settings, caches). However, it does not explicitly state that data is permanently deleted, cannot be recovered, or note any permissions required, which is significant for a destructive operation without annotations.

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 concise sentences, with the action and scope in the first sentence and a use case in the second. No wasted words.

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 destructive tool with no annotations and no output schema, the description leaves important gaps: no warning about data loss permanence, no mention of what response to expect, and no parameter guidance. The provided use case is helpful but does not fully cover operational context.

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 description coverage is 0%, and the description does not mention the parameters package_name or device_id. It does not explain how to specify the app or the optional device, leaving parameter semantics entirely to the user.

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

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

The description uses a clear verb 'Clear' and specifies the resource 'an app's data', with an additional clarifying phrase 'resets it to freshly-installed state'. This distinguishes it from sibling tools like quest_install or quest_uninstall, which have different actions.

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

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

The description provides a concrete use case: 'Useful for wiping test state (saves, settings, caches)'. This signals when the tool should be used, though it does not explicitly state when not to use it or name alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the prerequisite (WiFi) and the outcome (cable can be unplugged), but does not explain what happens if the headset is not on WiFi, whether the USB connection is lost, or how the wireless connection is established. This is adequate but leaves gaps about failure modes and 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 two short sentences with no filler. It front-loads the core action and then adds a necessary prerequisite, making it highly concise and efficient.

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 state-changing tool with no annotations and no output schema, the description provides the essential purpose and a key prerequisite. However, it omits parameter guidance (device_id) and any mention of error conditions or expected results. It is minimally complete but would benefit from explaining device selection and connection failure scenarios.

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

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

The input schema has one optional parameter 'device_id' with 0% description coverage, and the tool description does not mention it at all. The agent gets no help understanding what device_id refers to, when to provide it, or whether it is needed if multiple headsets are present. The description adds no meaning beyond the schema's bare field name.

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

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

The description clearly states the action: 'Switch the USB-connected headset to wireless ADB' with the purpose 'so the cable can be unplugged.' This specific verb+resource combination distinguishes it from sibling tools like quest_info or quest_devices, leaving no ambiguity about what the tool does.

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 gives a clear usage condition: 'The headset must be on WiFi.' It also implies when to use the tool (when you want to unplug the USB cable). However, it does not explicitly mention alternatives or when not to use it, such as when the headset is not on WiFi.

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

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

No annotations are provided, so the description carries the burden. It discloses the source (system dropbox), ordering (most recent first), and content (full stack trace), which adds useful context. Yet it does not explicitly state read-only behavior, device prerequisites, or the outcome when parameters are omitted.

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

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

The description is two sentences, front-loaded with the primary action and scope, and contains no filler. Every sentence contributes meaningful details about what is returned and how to filter.

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, but the description lacks guidance on default behavior (e.g., all devices) and does not differentiate from siblings like quest_logs beyond the crash/ANR focus. With no output schema or annotations, operational details remain unclear, though the core purpose is 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 schema has two optional parameters with no descriptions, and the description only elaborates on package_name. Device_id is never explained, and the default behavior when both parameters are null is not addressed. With 0% schema coverage, this is a notable gap.

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

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

The description clearly states the tool retrieves crash and ANR reports (Java, native, ANRs) from the system dropbox, most recent first. This distinguishes it from sibling log tools like quest_logs and quest_logs_stream by specifying a particular source and content type.

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

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

The description implies usage for investigating crashes, especially with the filter by package_name guidance. However, it does not explicitly contrast with alternative log tools or specify when not to use it, so there is clear context but no 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?

With no annotations provided, the description carries the burden of explaining behavior. It clearly indicates this is a read-only listing operation (via 'List') and describes the output semantics, including the possible connection states (device/unauthorized/offline) and wireless flag. It doesn't mention prerequisites or edge cases, but for a simple enumeration tool this is adequate.

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

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

The description is two sentences, front-loads the core purpose, and each sentence adds valuable detail. There is no fluff, and the return-field list is compact yet informative.

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

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

Despite having no parameters and an output schema, the description provides the essential context: what devices are listed, what connection states are included, and a usage recommendation. It is complete for a discovery-type tool and fits well among the sibling tools.

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 schema already covers all inputs trivially. The description adds value by explaining what the output contains, but no parameter semantics are needed. Baseline 4 is appropriate per the rubric for no-parameter tools.

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 the specific verb 'List' and identifies the resource as 'connected Quest/Android devices,' clearly distinguishing this tool from siblings that perform actions like connecting, installing, or launching. It also details key return fields (serial, model, connection state, wireless status), removing ambiguity.

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

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

The description gives an explicit usage hint: 'Use this first if unsure what is connected.' This tells the agent when to choose this tool over alternatives. However, it doesn't explicitly mention when not to use it or name specific sibling alternatives, so it doesn't fully earn a 5.

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

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

With no annotations, the description carries the burden of disclosing behavior. The verb 'List' clearly implies a read-only, non-destructive operation, and the path hint provides useful domain context. However, details like recursion, hidden files, error behavior, or return format are not disclosed, leaving some ambiguity.

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 compact two-sentence structure that front-loads the core purpose and then adds a genuinely useful path hint. Every sentence earns its place, with no filler or redundant content.

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's simplicity is matched by a clear main action, so the description is functional. However, it lacks return-value hints (no output schema), details about recursion or filtering, and explicit parameter requirements, which would be necessary for fully autonomous invocation in an agent context.

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 explicitly define device_path or device_id. The app-data path hint indirectly suggests what to pass as device_path, but it falls short of explaining the path format, the optional device_id, or the relationship between parameters.

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

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

The description uses a specific verb ('List') and resource ('a directory'), making the tool's action immediately clear. The added app-data path hint also distinguishes it from sibling tools that deal with apps or file transfer, fully clarifying its scope.

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 alternative guidance is given, but the app-data path hint implies this tool is meant for browsing device directories, especially app-private storage. It does not exclude use for other paths or mention when to prefer push/pull tools, leaving usage context vague.

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

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

With no annotations provided, the description discloses useful behavioral traits: it captures ~6s of the VrApi metrics stream and falls back to gfxinfo for non-VR apps. It does not mention prerequisites, permissions, or whether the capture is a blocking call, leaving some transparency gaps.

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

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

The description is compact, front-loaded with the core action, and every sentence adds value: metrics, capture duration, and fallback behavior. No fluff or irrelevant 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?

It covers the main purpose, metrics, capture window, and fallback, but lacks detail on return value structure and parameter semantics. Since there is no output schema and no annotations, the description should explain more about what the agent will receive and how parameters affect the call, making it only partially 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 schema has 0% description coverage and the description does not explain device_id or package_name. While the parameter names are self-explanatory, the description adds no meaning beyond the schema's names and defaults, and it does not clarify how these parameters are used or their optionality implications.

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

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

The description uses a specific verb ('Get') and resource ('live VR frame timing for the running app'), and enumerates the exact metrics returned (FPS vs target, stale frames, GPU/CPU utilization, app GPU time vs frame budget). This distinguishes it from sibling tools like quest_app_memory or quest_thermal by focusing on VR frame timing.

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 clearly indicates the tool is for a running app's VR frame timing and notes the fallback to gfxinfo for 2D/panel apps, providing context on when it applies. However, it does not explicitly name alternatives or state when not to use it, so it stops short of full comparative guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It lists output fields but does not state whether the operation is read-only, requires a connected device, or what happens on error or missing device.

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 concise sentence with a front-loaded verb and a compact list of return items. No words are wasted and the structure is easy to parse.

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

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

Despite the tool's low complexity, the description is incomplete for an agent: it leaves the device_id parameter behavior unexplained, omits return format details, and does not address error or connection requirements. The absence of an output schema makes these gaps more significant.

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 single parameter device_id is optional with default null, but the description does not mention it at all. With 0% schema description coverage, the agent gets no help understanding how to use or omit this parameter.

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

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

The description states a specific verb ('Get') and resource ('detailed device info'), enumerating concrete fields such as model, OS/firmware, battery, storage, WiFi IP, and thermal status. This clearly distinguishes it from sibling tools like quest_devices or quest_thermal.

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

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

No guidance is provided on when to use this tool versus alternatives, and there are no exclusions or prerequisite conditions mentioned. The description implies usage only through its purpose, but does not explicitly compare to siblings or state suitable contexts.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses two important behaviors: the installed APK replaces an existing install (upgrade) and setting grant_permissions=True auto-grants all runtime permissions. This goes beyond a simple 'install' statement, though it does not cover device selection or error handling.

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 only two sentences and is front-loaded with the primary action. The additional details about upgrade behavior and the grant_permissions flag are concise and valuable, with no unnecessary 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 install tool with no annotations and no output schema, this description is adequate but incomplete. It covers the main action, upgrade behavior, and the permission flag, but omits any explanation of device_id, which is important for multi-device environments. It also does not describe return values or failure scenarios.

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 has 0% description coverage, so the tool description must compensate. It explains the grant_permissions parameter fully, but apk_path and device_id are not explained. While apk_path is self-explanatory by name, device_id's optional behavior and default are not clarified, leaving ambiguity when multiple devices are connected.

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

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

The description clearly states the tool's function: 'Install (sideload) an APK onto the headset.' This specifies a concrete verb and resource, and the addition of 'Replaces an existing install of the same package (upgrade)' distinguishes it from sibling tools like quest_uninstall and quest_push.

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 gives clear context for when the tool is appropriate (installing an APK) and provides usage guidance for the grant_permissions parameter, specifically noting it is 'useful for test builds.' However, it does not explicitly mention alternatives or when not to use this tool, such as saying to use quest_uninstall for removal.

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?

Without annotations, the description carries the full burden of behavioral disclosure. It only states the action ('Launch an app') and the target identifier ('package name'), but does not disclose what happens after launch (e.g., whether it returns success/failure, if it waits for the app to start, or errors on missing apps). It also fails to mention that launching is a state-changing operation or whether it requires authentication/device permissions.

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

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

The description is a single sentence that is front-loaded with the core action and includes a concrete example. Every word contributes value; there is no wasted or redundant text. It is appropriately concise for a simple tool, though it could be longer to cover missing details, but conciseness is well-executed.

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 annotations and no output schema, the description is incomplete. It does not mention the return value, error handling, or side effects. It also leaves device_id unexplained, which is necessary for multi-device environments. While the tool is simple, the lack of behavioral and parameter completeness makes it difficult for an agent to invoke it correctly in all scenarios.

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 must compensate for both parameters. It adds meaning for package_name by explaining its purpose and format with an example, but it completely omits any explanation of device_id, including its default behavior (null) or how to select a specific headset. This leaves a significant gap for one of the two parameters.

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

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

The description clearly states the tool's purpose: launching an app on the headset by package name. It uses a specific verb ('Launch') and identifies the resource ('app on the headset') and the method ('by package name'), with an example that illustrates the expected input format. This distinguishes it from sibling tools like quest_install (install) and quest_stop (stop).

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 tool is used to start an installed app on the headset, but it provides no explicit guidance on when to use it versus alternatives such as quest_launch_benchmark (which likely launches with performance measurements). There are no clear exclusions or scenarios where this tool should not be used, and no mention of prerequisites like the app being installed or the device being connected.

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

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

With no annotations, the description carries full burden. It discloses the destructive force-stop behavior, the repeated launches (N times), and the return values (per-run timings and min/median/max). It also adds a max of 5 runs constraint. It doesn't mention permissions or post-conditions but covers the key behaviors.

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, followed by output details and use case. No wasted words.

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

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

For a tool with no output schema and no annotations, the description covers the action, the return values, and the intended use case. The force-stop behavior is explicitly noted. It doesn't describe device_id semantics, but that's a standard parameter across sibling tools.

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 has 0% description coverage, so the description must compensate. It references 'N times (max 5)' which maps to the runs parameter but doesn't explicitly name it. package_name and device_id are not described, though their purposes are inferable from context. The description adds a max constraint absent from the schema.

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

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

The description clearly states the tool benchmarks an app's cold-start time via force-stop and timed launch, with specific output details. This distinguishes it from sibling tools like quest_launch (simple launch) and quest_performance (broader metrics).

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

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

It explicitly states the use case: 'useful for measuring startup optimizations,' which gives clear context for when to use. However, it doesn't mention alternatives or exclusions, like using quest_launch for a single launch or quest_stop alone.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It does explain significant behavior: level is minimum severity with a default, tag scopes to one tag, and pattern is a case-insensitive regex over tag+message. However, it omits behavior for device_id and lines, and does not explicitly state that this is a non-streaming one-time fetch.

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 compact, front-loaded with the core purpose, and each sentence adds useful parameter information. There is no fluff or redundancy. The multi-line structure improves readability without adding length.

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 provides the output shape and key filters, which is helpful given no output schema exists. However, it is incomplete for a 5-parameter tool with no annotations: device_id and lines are absent, and the relationship with quest_logs_stream/quest_crash_logs is not clarified. It adequately covers the main use but leaves important context 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?

Schema description coverage is 0%, so the description must compensate. It does add meaningful semantics for level (V/D/I/W/E/F, minimum severity, default W), tag (scopes to one log tag), and pattern (case-insensitive regex over tag+message). However, lines and device_id are not explained at all, leaving 2 of 5 parameters without sufficient meaning.

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

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

The description opens with a specific verb and resource: 'Get recent logcat entries as structured logs'. It clearly states what the tool does and distinguishes it from sibling tools like quest_logs_stream by emphasizing 'recent' one-shot retrieval. The output format (timestamp/level/tag/message) is also specified.

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 guidance is given about when to use this tool versus alternatives such as quest_logs_stream or quest_crash_logs. The description explains parameter filtering but does not say when a one-shot log fetch is preferred over streaming or crash-specific logs. Usage is implied rather than 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?

With no annotations, the description carries the full burden and it discloses the core behavior: real-time capture for a configurable duration, a hard 60-second cap, and return of captured logs. It does not discuss blocking behavior or filtering details, but the essential behavior is transparent.

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

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

Two sentences, front-loaded with the action and key parameter, followed by a practical workflow. Every sentence earns its place 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?

For a real-time log stream with optional filters and no output schema, the description covers the main workflow and the most important constraint (max 60 seconds). It lacks parameter semantics and return format, but the tool is simple enough that this is largely sufficient.

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

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

Schema coverage is 0%, yet the description only elaborates on duration_seconds (including the max 60 constraint). It does not explain the meaning or interaction of tag, level, pattern, device_id, or max_entries, leaving those parameters underspecified.

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 the specific verb 'Watch logs in real time', identifies the resource (logs), and mentions the key parameter duration_seconds. It clearly distinguishes itself from sibling log tools by emphasizing real-time streaming and returning everything captured.

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

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

It explicitly says when to use: while reproducing a bug, start this, interact with the app, then get the logs. It does not mention alternatives or when not to use, but the context is clear enough for a focused workflow.

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

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

With no annotations, the description carries the full burden. It discloses the 'max 120s' limit and the timeseries return format, providing some transparency, but it does not mention potential side effects, prerequisites, or how it behaves during monitoring.

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

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

The description is two sentences, front-loaded with the core action and constraint, and the second sentence gives valuable usage guidance. No wasted words.

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 with optional params and no output schema, so the description provides adequate purpose and usage. However, it lacks parameter documentation and detailed return format, which is a notable gap given no 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 coverage is 0%, so the description should explain parameters. It only hints at the duration cap ('max 120s') and does not clarify device_id or interval_seconds, leaving most parameter semantics 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 clearly states the tool monitors performance over time and returns a timeseries of snapshots, which is a specific verb+resource. It distinguishes from sibling tools like quest_performance by emphasizing the temporal aspect and max duration.

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 explicit context: 'Use while exercising an app to spot CPU spikes, memory growth, or thermal climb.' This tells the agent when to use it, though it doesn't name alternatives or 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?

No annotations are provided, so the description carries the full burden. It transparently states that the tool returns metric deltas and verdict change, implying a read-only comparison operation. However, it does not explicitly disclose the absence of side effects or detail behavior for invalid/missing files. For a diff tool, the core behavior is adequately described, but some behavioral context is left to inference.

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

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

The description is two sentences, front-loaded with the primary action and resource, and every phrase adds value. It avoids restating the tool name or schema details, and the example use case is efficient.

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 simple two-parameter interface and no output schema, the description is mostly complete: it explains the input source (JSON files from quest_perf_session), the purpose (comparison), and the output (metric deltas and verdict change). It could add nuance about file path expectations or exact format, but this is not critical for basic usage.

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%, but the parameter names 'before_session_path' and 'after_session_path' are self-explanatory. The description adds valuable context by specifying these are JSON files from quest_perf_session and reinforcing the before/after relationship, which compensates for the lack of schema descriptions.

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

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

The description clearly states the tool compares two recorded perf sessions, with a specific verb ('Compare') and resource ('recorded perf sessions (JSON files from quest_perf_session)'). It also gives a concrete use case (before/after an optimization) and distinguishes it from sibling tools like quest_perf_session (which records) and quest_performance (which likely monitors).

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

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

The description clearly implies when to use this tool: when you have two saved perf sessions and want to compare them, especially before/after an optimization. It does not explicitly name alternatives or state when not to use it, but the context is strong enough to guide selection among the sibling 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?

In the absence of annotations, the description takes on the responsibility of disclosing behavior. It gives useful context such as the battery drain sign convention (negative = discharging) and lists the snapshot contents, but it does not explicitly state whether this is a read-only operation, what the output format is, or whether device_id is required.

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 efficiently communicates the core function and the list of returned metrics. There is no redundant filler, making it easy to parse quickly.

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

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

The tool has no annotations and no output schema, so the description is the sole source of operational context. It enumerates the metrics returned, which is helpful, but it leaves critical gaps: it doesn't specify the output structure (e.g., units, JSON layout), the meaning or optionality of device_id, or the behavioral safety profile (read-only vs. side effects). For a tool with such minimal structured context, this is partially 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 single parameter device_id is completely undocumented in both the input schema (no description) and the tool description (not mentioned). With 0% schema description coverage, the description fails to compensate, leaving agents to guess whether device_id is required, what values are valid, or what the default null means.

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 the specific verb 'Get' and resource 'performance snapshot', and enumerates specific metrics (CPU, memory, thermal status, battery, foreground app, top processes). This clearly defines the tool's function, but it does not explicitly differentiate it from related sibling tools like quest_thermal or quest_monitor, which may offer overlapping subsets of these metrics.

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

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

The description provides no information about when to use this tool versus the many siblings (quest_thermal, quest_monitor, quest_perf_session, etc.). There are no context cues, prerequisites, or exclusions, leaving the agent without guidance on tool 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 full transparency responsibility. It discloses the max duration (300s), what data is collected (per-second VrApi metrics, memory anatomy, thermal timeline), that a JSON file is saved and its path returned, and the default app behavior. This is substantial behavioral context, though it does not mention potential side effects like storage consumption or performance overhead during recording.

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 compact and front-loaded: the first sentence states the core action and expected return, followed by targeted use context, file output details, and the default behavior. Every sentence adds information; the list of diagnosis types is concise yet illustrative. No wasted words.

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 complex session-recording tool with no output schema, the description covers the essential context: what it records, what it returns, the saved file path, the connection to quest_perf_diff, and the defaults. It even hits on practical usage ('Use while the user exercises their app'). There is no obvious missing piece that would leave an agent confused about how to invoke or interpret the 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 must compensate. It does add meaning by noting the max session length (300s) and the 'Defaults to the current foreground app' behavior, which hints at package_name/device_id being optional. However, device_id is not explicitly explained, and duration_seconds is only implied by 'max 300s.' The description adds some value but does not fully cover all three parameters.

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

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

The description opens with a specific verb-resource pair ('Record a full performance profiling session') and clearly enumerates the tool's deliverables: a summary, a bottleneck diagnosis with evidence/recommendations, and notable events. It also differentiates itself from sibling tools by mentioning the saved JSON file and the link to quest_perf_diff, making its unique role unmistakable.

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 gives explicit timing guidance: 'Use while the user exercises their app in the headset.' It also clarifies that the tool defaults to the current foreground app, which implicitly tells the agent when parameters can be omitted. It mentions the relationship to quest_perf_diff for comparisons but does not explicitly state when not to use this tool in favor of monitoring or tracing 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?

No annotations are provided, so the description carries the full burden. It mentions the operation direction but does not disclose whether the operation overwrites existing files, requires permissions, or whether the source file is left intact. The description lacks behavioral details such as error handling, side effects, or prerequisites, making it inadequate for a tool with zero annotation coverage.

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

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

The description is a single, front-loaded sentence with no fluff. It states the verb, resource, and direction efficiently. Every word earns its place, and the parenthetical example adds useful context without redundancy.

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

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

With no annotations, no output schema, and 0% parameter documentation, the description is far too brief to be complete. It does not address multi-device handling via device_id, potential conflicts with existing local files, or how it relates to sibling tools like quest_logs. The tool is simple, but the lack of behavioral and parametric detail makes this inadequate for reliable invocation.

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 any of the three parameters. The parameter names (device_path, local_path, device_id) are somewhat self-explanatory, but the description adds no meaning beyond them, leaving device_id's purpose and required format unclear. It fails to compensate for the complete lack of schema documentation.

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

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

The description clearly states the action: 'Pull a file from the device to the local filesystem' with a specific source and destination. It includes a concrete use case ('save files, logs written by the app') that distinguishes it from siblings like quest_push (which pushes to the device) and quest_files (which lists files).

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 gives clear context for when to use the tool ('e.g. save files, logs written by the app'), implying retrieval of files from the device. It does not explicitly exclude alternatives or name sibling tools, but the directionality and example provide sufficient guidance for an agent to select it appropriately.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It only states the action without mentioning overwrite behavior, directory creation, or prerequisites like device connectivity, which is a significant gap for a file transfer tool.

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 concise sentence with an example, front-loaded with the verb and resource. No fluff or redundant 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 push tool, the description covers the basic purpose and gives an example, but lacks behavioral details and parameter semantics. Given no annotations or output schema, it is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It gives an example for local_path and device_path but does not explain the optional device_id parameter or provide any syntax details beyond the obvious.

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

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

The description clearly states the action ('Push a local file') and the target ('to the device'), with an example path that adds concrete context. This distinguishes it from siblings like quest_pull and quest_install.

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 use case (copying files to the device) and provides an example, making the context clear. However, it does not explicitly contrast with alternatives or mention when not to use it, but the operation is distinct 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?

With no annotations, the description carries the burden and does disclose the core behavior: recording for N seconds, saving an MP4, and returning the file path. It does not cover consequences like file overwriting, device connection requirements, or failure modes, limiting transparency.

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

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

The description is two sentences, front-loads the action, and includes only relevant details.

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

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

The description includes the key aspects: duration limit, output type, and return value, which is sufficient for a simple tool. Yet the lack of parameter semantics and no output schema leave some ambiguity about how to specify the save path and device, so it's not fully complete.

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

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

Schema description coverage is 0%, but the description hints at duration limits ('max 180') and that a file is saved locally, partially covering duration_seconds and save_path. It does not address device_id or explain parameter formats, so compensation is insufficient.

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

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

The description clearly states the tool records the headset screen for a specified duration and saves an MP4 file locally, using a specific verb and resource. It also notes the return value (file path), which distinguishes it from the sibling quest_screenshot.

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 provides a clear use case ('useful for capturing a bug repro') that helps an agent decide when to select it. However, it does not explicitly mention alternatives or when not to use it, so it lacks exclusion 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 provided, and the description adds behavioral details: it auto-wakes the display and optionally saves to a PNG path. However, it does not discuss conditions like failure modes, connection requirements, or what happens if the display is off. It provides some context but not comprehensive 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?

Three concise sentences, front-loaded with the primary action, then behavior notes. Every sentence adds value; no redundancy.

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

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

For a simple screenshot tool, the description covers the main purpose, return value, auto-wake behavior, and optional save path. Since there is no output schema, it adequately explains the return. Minor gaps like explicit image format for the returned image are not critical.

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 has 0% description coverage. The description explains the 'save_path' parameter (optionally saves PNG) but says nothing about 'device_id' beyond what the bare name implies. This partially compensates for the schema gap but does not fully clarify both parameters.

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

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

The description clearly states the action ('Take a screenshot'), the target ('what's currently displayed in the headset'), and the output ('return the image'). It distinguishes from sibling tools by emphasizing a still image rather than video (like quest_screen_record).

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 indicates the general purpose but does not explicitly contrast with sibling tools such as quest_screen_record or specify when to use this over alternatives. The context is implied but lacks exclusions or alternative guidance.

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

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

With no annotations, the description bears the burden of disclosing behavior. It correctly notes that this is a 'hint' and that apps can override it, which is a crucial nuance. It doesn't cover persistence or connection requirements, but it covers the most important behavioral caveat.

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

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

The description is two sentences, front-loaded with the verb, and contains no unnecessary information. It is concise and well structured.

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 simple tool and minimal schema, the description covers essential purpose, valid values, and a critical caveat. It omits details about device_id and potential return/error behavior, but overall it provides sufficient context for basic usage.

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 must compensate. It explains the 'rate' parameter by listing allowed values, but it doesn't clarify the 'device_id' parameter or its default behavior. This partial clarification earns a middle score.

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

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

The description clearly states the tool sets a display refresh rate hint, specifying the resource (display) and action (set). It also includes specific allowed values, distinguishing it from other Quest-related tools that don't address refresh rate.

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 provides context by identifying the target device (Quest 3) and valid rates, and warns that apps requesting an explicit rate override the hint. It doesn't explicitly name alternatives or exclusions, but the use case 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?

No annotations are present, so the description must disclose side effects; it only states 'Force-stop' without explaining process termination consequences, loss of app state, behavior for non-running apps, or device targeting. This is minimal behavioral disclosure for a mutating operation.

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

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

One short, front-loaded sentence communicates the core action with no redundancy or 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?

Despite low complexity, the tool performs a mutation and has no annotations or output schema. The description omits parameter semantics, side effects, and device selection, leaving important invocation context unstated.

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 description adds no parameter explanations. 'package_name' is required but its format is not described, and 'device_id' is optional with a null default but no guidance on when to provide it.

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

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

The description uses a specific verb ('Force-stop') and resource ('a running app') with scope ('on the headset'), clearly distinguishing it from sibling tools like quest_launch or quest_uninstall. It directly states the tool's core action without ambiguity.

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

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

No explicit when-to-use or alternative guidance is provided. The phrase 'running app' implies it applies to apps currently active, but the description doesn't mention when not to use it or how it relates to quest_launch or quest_uninstall.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains the throttling behavior (Quest throttles CPU/GPU as skin temps climb) and what the tool surfaces (warning/critical flags), which adds meaningful context. It doesn't explicitly state side effects, but as a read-only check this is acceptable.

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

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

The description is two sentences. The first sentence front-loads the tool's purpose and outputs; the second provides useful context. Every word earns its place, with no redundant phrasing or unnecessary 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 simple read-only tool with one optional parameter, the description covers what it returns and why to use it. The only notable gap is the unmentioned device_id parameter, which prevents a perfect score. Given the tool's simplicity, this is still well-rounded.

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 has one optional device_id parameter with 0% description coverage in the schema. The description does not mention device_id at all, leaving the agent to infer its meaning. Since the description must compensate for low schema coverage and fails to do so, the score is low.

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 explicitly states 'Check thermal state' and lists exactly what information is returned: throttle status, all temperature sensors with warning/critical flags, and max skin temperature. This is a specific verb+resource combination that clearly distinguishes the tool from siblings like quest_performance or quest_monitor.

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

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

The description provides clear usage context: 'watch for warnings during long play sessions' directly ties to the tool's purpose and explains when to use it. However, it does not mention alternative tools or explicitly state when not to use it, 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?

With no annotations, the description carries the full burden. It discloses the maximum duration (max 60s), the output file format (.pftrace), and where to view it (ui.perfetto.dev). It also specifies the trace content, which implies a read-only diagnostic operation. However, it does not mention any potential system impact or permission requirements, leaving minor gaps.

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

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

The description is three sentences, each earning its place. It states the action, the content, the use case, and the output viewing URL in a compact, front-loaded manner with no redundancy 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?

For a trace tool with no output schema and no annotations, the description covers the essential context: what events are captured, when to use it, the maximum duration, and how to view the result. It does not detail return values or save path specifics, but those are less critical given the tool's diagnostic nature.

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 must compensate. It only hints at the duration via 'max 60s' but does not explicitly map this to the duration_seconds parameter. It provides no explanation for device_id or save_path, leaving the agent to guess their roles based solely on 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?

The description clearly states the tool's function: 'Capture a perfetto system trace' with specific event types listed (per-thread scheduling, CPU frequencies, graphics events). This distinguishes it from sibling tools like quest_screenshot or quest_logs, which serve different purposes.

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 gives explicit usage context: 'Use when session metrics show a problem (hitches, CPU-bound) and you need to see exactly what blocked.' It provides a clear 'when to use' but does not mention when not to use or alternative tools, so it misses the full exclusion 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 provided, so the description must carry the full burden. It adds the caveat 'if exposed' about guardian boundary state, but does not disclose whether the operation is read-only, possible errors, or the output format. For a status check, this is minimal transparency.

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

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

The description is a single, front-loaded sentence that lists the checked components efficiently. Every word contributes to understanding the tool's scope, with no redundancy 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?

The description is adequate for a simple status check but leaves gaps: it does not explain the device_id parameter, clarify the expected output structure, or provide any error/edge-case context. With no annotations or output schema, the description is only partially 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 only parameter, device_id, is not mentioned in the description. Schema description coverage is 0%, and the description does not compensate by explaining the parameter's purpose or effect. The agent receives no guidance for this optional parameter.

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 specifies a clear action ('Check tracking subsystem status') and explicitly lists the components (head/hand/eye/body/controller) plus guardian boundary state. This distinguishes it from sibling tools like quest_info and quest_devices, which cover different aspects.

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 when tracking status is needed, but does not explicitly compare to alternatives or state when not to use this tool. Given the large set of sibling tools, explicit guidance would be more helpful, but the purpose is clear enough to infer correct 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?

With no annotations, the description carries the full burden, but it only says 'Uninstall an app'. It does not disclose potential data loss, irreversibility, or system restrictions, which are important for a destructive action.

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

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

The description is a single, front-loaded sentence with no filler. It is efficient and immediately communicates the core 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 destructive tool with no annotations and no output schema, the description is too sparse. It omits the role of device_id, potential side effects, and clarifying constraints like supported apps or permissions.

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 description mentions 'by package name', giving meaning to the required package_name parameter. However, device_id is completely unaddressed, and schema coverage is 0%, so half of the parameters lack adequate explanation.

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

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

The description uses a specific verb ('Uninstall'), names the resource ('app'), and specifies the method ('by package name'). It clearly distinguishes from siblings like quest_install and quest_app_info.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of situations where uninstall is appropriate or not, nor any comparative reference to sibling tools.

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