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

No annotations are provided, so the description carries the full burden, yet it says nothing about read-only status, pagination, ordering, filtering, or whether results are scoped to a single active profile. It discloses only the content categories a caller might expect, which is minimal behavioral context.

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 with no filler, and the most informative part (what artifacts exist) is front-loaded after the scope phrase. It is perhaps too terse to earn a 5.

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

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

For a zero-parameter, no-output-schema listing tool this is minimally sufficient: the agent knows the artifact categories it will get. However, nothing explains result shape, recency/pagination, or profile scoping, which a list tool's caller would reasonably need.

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

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

The tool takes zero parameters and the schema is an empty object, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies.

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

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

The description names the resource (artifacts produced by the profile) and enumerates concrete artifact types (screenshots, downloads, PDFs, recordings), which lets an agent distinguish it from production siblings like screenshot, record, and save_pdf. The listing verb is only implied through the tool name, so it falls short of the sharpest verb+resource statement.

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

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

There is no guidance on when to call this instead of the many sibling listing tools (run_list, task.list, session.export, page_report) or any prerequisite/context. The agent must infer usage entirely from the name.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It says nothing about side effects a click may trigger (navigation, downloads, popups) or any prerequisites, leaving the most consequential aspects of a click tool undocumented.

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

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

A single sentence, but it is under-specified rather than efficient: the trailing clause adds ambiguity instead of information, and no actionable detail is front-loaded.

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-annotation, zero-parameter click tool with no output schema, the agent is left with no way to know what to click or what will happen. Neither the schema nor the description supplies the targeting or effect information required to invoke it correctly.

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

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

The schema is empty (0 params, vacuous 100% coverage), which normally earns a baseline 4 for parameter semantics. However, the description references an 'optionally a point inside it' target that does not exist in the schema, creating a mismatch that undermines otherwise-trivial parameter semantics.

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

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

The verb+resource ('Click an element') is clear, but the tail 'for a picture rather than a control' is cryptic and reads as a partial target-scope hint rather than a distinguishable statement of purpose. It does not cleanly separate this from siblings like press_and_hold or interact.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternatives among the many sibling interaction tools. The 'picture rather than a control' phrase is the only hint at selection criteria, and it is too vague to route an agent reliably.

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, and it discloses almost nothing: no return format for reads, no explanation of how a write is sourced given zero input parameters, no permission or security implications despite clipboard access being sensitive, and no note on whether it affects the system clipboard or a page-scoped one.

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 resource front-loaded and no filler. It is appropriately sized, though its brevity comes at the cost of the missing detail noted elsewhere.

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 annotations, no output schema, no parameters, and security-sensitive clipboard access, the description is far too thin. It leaves the read/write dispatch, the write data source, and the return value entirely unspecified.

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

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

There are no parameters, so the baseline is 4 by rule; however, the description implies a read/write mode selection that the schema does not expose, creating an unresolved mismatch rather than adding meaning. The description therefore neither documents nor compensates for the absent mode selector.

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 (clipboard) and the scope (bound tab), and gives both possible verbs (read/write). However, it conflates two distinct operations into one tool without saying how the agent selects between them, and the empty schema offers no mode switch. An agent knows what the tool touches but not which action it will perform.

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 siblings such as read_text, read_value, type_text, or fill_form, all of which touch page content. No prerequisites, no exclusions, and no indication of when a read versus a write is triggered.

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 for a destructive operation. It conveys scope (one cookie vs. all cookies of a site) but says nothing about irreversibility, required permissions, or what happens when the site/cookie is not found.

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

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

A single front-loaded sentence with no filler, which is efficient for a simple tool. It borders on under-specification rather than wasting words, so full marks are not warranted.

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 cookie-removal tool with no output schema and no annotations, the description covers the action but omits how the target is identified and the safety profile of an irreversible delete. Adequate but with visible gaps for a destructive operation.

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 zero parameters, which per the baseline would warrant a 4. However, the description promises two distinct targeting modes ("one cookie" or "every cookie of one site") that the empty schema provides no way to express, leaving the agent with no documented mechanism for selecting a cookie or site.

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 ("Remove") and resource ("cookie") plus a clear scope: a single cookie or all cookies of one site. It is unambiguous about what the tool does, but it never names or contrasts with the obvious sibling cookie_list.

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

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

There is no explicit guidance on when to use this versus cookie_list, nor any mention of prerequisites, confirmation requirements, or when deletion is inappropriate. The two deletion modes are stated but not framed as a choice the agent must make.

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-disclosure burden. It does add one useful trait—'Never a value'—indicating it will not return cookie contents, but it omits authorization needs, mutation status, pagination, and return shape, leaving most behavioral context unstated.

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 short and wastes no words, but its first sentence is metaphorical rather than action-oriented, and the caveat is not front-loaded. It is concise yet under-structured for reliable tool selection.

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 an empty input schema, no annotations, and no output schema, the description must do all the explanatory work. It only states that the result is about the cookie jar's shape and excludes values, but it never says what the tool actually returns or when to invoke it, making the definition incomplete for a zero-parameter listing 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?

The tool takes zero parameters, so there is no parameter information to document. Per the baseline for a parameterless tool, a 4 is appropriate; the description neither helps nor hurts because no parameters exist.

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

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

The description hints at returning cookie metadata rather than values, but it never states the action (e.g., 'list cookies') or what 'shape' concretely means. An agent can guess it is a non-destructive read of cookie structure, yet the purpose remains vague compared to a specific verb+resource statement.

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 such as cookie_delete or credential.list. The description provides no context, exclusions, or prerequisites, leaving selection entirely to inference.

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

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

With no annotations, the description carries the full burden and does contribute one important behavioural fact: the agent never receives the credential, which tells the caller not to expect secret material back. However, it omits whether a profile must be started/leased first, what happens on auth failure, and whether the action is reversible or has side effects on the profile.

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

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

Two short sentences with zero filler, and the core action is front-loaded before the security caveat. Nothing is wasted or padded.

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

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

For a zero-parameter action tool the description covers the essential action and the credential-handling property, but it leaves out the prerequisite state (which profile, whether it must be leased or started) that an agent needs to invoke it successfully in the right sequence.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. The description correctly implies the target is implicitly the active profile rather than an argument.

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

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

States a concrete action (sign in) performed against a specific resource (this profile's stored login), which is more informative than a tautology. It is distinguishable from sibling tools like credential_store or credential_new in kind, though the description never names those siblings to make the boundary explicit.

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

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

There is no when-to-use guidance, no stated prerequisites, and no mention of alternatives such as credential_store (to save a login) or lease_profile/profile.start (to obtain a profile context). The agent must infer that this is the tool for authenticating with previously stored credentials.

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 disclosure burden. It usefully signals that only non-secret account names are returned, but it does not state whether authentication is required, how the relevant profile is determined (the schema takes zero parameters, yet the text says 'a profile'), or how results are scoped.

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 terse, front-loaded sentences with zero filler, and the safety-relevant fact is placed inline rather than buried. It is arguably over-terse sentence-fragment prose, which slightly limits clarity but nothing is wasted.

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 parameterless read tool with no output schema, the description adequately sketches the return content (platforms and account names) and its non-secret nature. However, with no annotations and no output schema, the unexplained profile-scoping mechanism leaves a real gap for an agent deciding how to invoke it correctly.

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

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

The schema declares zero parameters and coverage is 100%, so per the rubric the baseline is 4. There are no parameters whose semantics the description could add or omit, and it correctly makes no parameter claims.

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 fragments describe the returned resource (platforms a profile can log into, plus account names) but never state a verb such as 'list', so the tool's action must be inferred from the name 'credential.list'. It does differentiate content-wise from credential_fill/credential_new/credential_store and secret_list by emphasizing 'never secrets', which helps an agent tell it apart from secret_list.

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

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

There is no statement of when to use this tool, no prerequisites, and no named alternatives among the many sibling tools (secret_list, credential_fill, credential_store, passkey_list). The only adjacent guidance is the implicit 'never secrets' boundary, which hints at a read-only metadata tool but does not say when to choose it.

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 does disclose a meaningful multi-step side effect: the daemon generates the password itself, persists it, and types it into the page. However, it omits key behavioral facts — where the text is typed (focused field vs. active page), whether the stored credential is later retrievable via credential.list, and irreversibility.

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, front-loaded with the scenario label, with no wasted clauses. It is arguably over-terse for a tool with three distinct side effects, but every clause earns its place.

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

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

For a zero-parameter tool with no annotations and no output schema, the description covers the core action but leaves the agent guessing about the target of the "types it" step and whether a value is returned or must be fetched separately. The absence of annotations means more, not less, explanation was warranted.

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 is an empty object with zero parameters, so there is nothing to document; the baseline for a no-parameter tool applies. The description correctly implies the tool needs no caller-supplied secret because the daemon draws 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 names a concrete scenario ("Sign up") and enumerates the three concrete effects: drawing a password, storing it, and typing it. That implicitly separates it from siblings like credential_store (persist a caller-supplied secret) and credential_fill (type an existing secret), though it never names those alternatives 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?

There is no explicit when-to-use guidance and no when-not-to-use or alternative routing, even though credential_store and credential_fill sit right next to it in the sibling list. "Sign up" vaguely implies the context (an open sign-up form) but nothing tells the agent which of the three credential tools to pick.

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 implies a write/persist operation into a vault but says nothing about whether an existing entry is overwritten, whether authorization is needed, whether the operation is durable or reversible, or what a successful store returns.

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

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

A single short sentence with the action front-loaded and no filler. It is not padded, though its brevity here stems partly from under-specification rather than disciplined editing.

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

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

For a mutating tool with no annotations, no output schema, and no parameters documenting how the credential is selected, the description leaves too much unresolved: overwrite behavior, prerequisites (loaded profile/session), and the relationship to credential_new and credential.list are all absent.

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

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

The schema exposes zero parameters, which would normally set a 4 baseline, but the description implies an input ("a login the profile already has") that the schema does not surface, leaving unclear how the target login is identified — presumably implicit session/profile state, which the description should have stated.

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 concrete verb ("Put ... into the vault") on a concrete resource (a login the profile already has), and the qualifier "the profile already has" implicitly distinguishes it from credential_new. It is clear enough to separate from credential_new, but it never names a sibling or clarifies vault vs. form-fill semantics versus credential_fill.

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

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

There is no explicit when-to-use or when-not-to-use guidance. An agent cannot tell from this text whether to use credential_store, credential_new, or credential_fill for a given credential, nor whether any precondition (an existing loaded profile) is required.

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 full behavioral burden. It discloses that the download result is kept as an artifact, but says nothing about waiting behavior, failure handling, overwrite behavior, or 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 front-loaded sentence with no wasted words. It is concise, though its brevity contributes to the ambiguity rather than resolving it.

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 no parameter guidance, the description is too thin for reliable invocation. It mentions an artifact result but does not clarify the download source, trigger context, or how the artifact should be retrieved.

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 itself is trivial and the description does not need to compensate for parameter documentation. Baseline for zero-parameter tools is 4.

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 rough verb+resource ('follow a download', 'artifact'), but 'follow' is ambiguous and it does not distinguish this tool from siblings such as save_pdf or artifact_list. An agent can infer it handles a download result, but the exact action remains vague.

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, when not to use it, or which alternative to choose. It does not say whether it should be called before/after a click or navigation that triggers a download.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what authentication or permissions are needed, how results are returned, or whether any side effects occur. This is a significant gap for a tool with zero structured behavioral hints.

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 fragment rather than a structured statement of purpose or usage. It is short, but that brevity reflects under-specification rather than efficient front-loading of useful information.

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

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

Given no annotations, no output schema, and zero parameters, the description should at least clarify what the tool returns and when it is appropriate. It only vaguely mentions the extension library and profile loads, leaving the agent to infer read-only behavior, return shape, and selection 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 input schema has zero parameters, so the baseline is 4. The description does not need to explain parameter meaning, and it does not introduce any parameter-related ambiguity.

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

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

The description identifies the resource ('extension library') and adds a secondary purpose ('what each profile loads'), but it omits a clear verb and is a sentence fragment. An agent can infer this is a listing tool from the name, yet the description does not explicitly state the action or 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?

There is no guidance on when to use this tool versus alternatives. Many sibling list tools exist (profile.list, credential.list, group.list, etc.), and the description gives no context, prerequisites, or exclusion conditions to distinguish extension.list from them.

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, and it discloses nothing about permissions, whether values are submitted or staged, what happens on partial failure, or what the call returns. For a mutation-flavored tool this is a complete gap.

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

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

It is short, but brevity here is under-specification rather than conciseness. One fragment with no front-loaded verb, object, or constraint earns no credit for efficiency.

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 an empty input schema, the description was the only channel left to explain a multi-field fill operation, and it supplies one ambiguous fragment. Nothing an agent needs to invoke this correctly is present.

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

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

The schema declares zero parameters, so by the baseline rule parameter semantics would be 4; however the description claims "several fields" are supplied, which the empty schema does not support or document. That mismatch between prose and schema makes the description less informative than silence would be.

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?

"Several fields in one call" is close to a tautology: it gestures at batching but never names the resource (a form) or the verb in a way that distinguishes this tool from credential_fill, type_text, or any other input sibling. An agent cannot confidently tell what is being filled.

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 when-to-use guidance, no mention of alternatives such as credential_fill or type_text, and no prerequisites. Nothing routes the agent to or away from this 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 are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the group persists, what happens on a duplicate name, what permissions or session state are required, whether the group is auto-selected afterward, or how failure is reported. The only implicit signal is that "create" is a state-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?

It is a single front-loaded sentence with zero verbal waste, which is good, but the brevity reflects under-specification rather than discipline given the description is the only source of semantics here.

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

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

For a zero-parameter, unannotated creation tool, the description should at least say what a group represents and where the created group comes from or goes. With no parameters, no annotations, and no output schema, the one-sentence description leaves core 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?

The input schema declares zero parameters, so there is nothing for the description to disambiguate; per the baseline for 0-param tools this is a 4.

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?

"Create a group" states a verb and a resource, so an agent knows the action is a creation of a group object. But it is essentially the tool name (group.create) expanded into a sentence, with no scope, no definition of what a "group" is in this product, and no distinction from group.list or group.delete. Minimum viable rather than 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?

There is no guidance on when to create a group versus using group.list or group.delete, and no prerequisites, ordering, or preconditions are mentioned. The agent must infer entirely from the name.

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

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

With no annotations present, the description carries the full disclosure burden. It does add one genuinely non-obvious behavioral fact — that member profiles survive the deletion (no cascade) — which is exactly the kind of side-effect an agent needs. However, it omits irreversibility, required permissions, and any other consequences of removing the group.

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 terse sentences with no filler; the destructive action is front-loaded and the important side-effect follows immediately. Every word earns its place.

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

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

For a zero-parameter delete tool with no annotations and no output schema, the description conveys the core action and the profile-preservation behavior but says nothing about reversibility, preconditions, or what is returned. It is minimally adequate rather than 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 zero parameters, so per the baseline there is nothing for the description to expand on and no coverage gap to compensate for. A 4 reflects that the empty schema is not a defect the description needs to fix.

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 ('Delete a group'), which is unambiguous and clearly distinct from the sibling group.list and group.create. It stops short of explicitly naming or contrasting those siblings, so it is clear rather than maximally differentiating.

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

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

There is no when-to-use guidance, no prerequisites (e.g., whether the group must be empty), and no mention of alternatives such as group.list for inspecting before removal. The agent is left to infer all situational context.

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

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

No annotations are provided, so the description carries the entire burden of behavioral disclosure. It discloses nothing about whether the operation is read-only, what a 'group' is, whether pagination applies, or what is returned — a critical gap for a list operation with zero structured support.

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

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

It is short, but brevity here is under-specification rather than conciseness: the single fragment is grammatically incomplete and front-loads no actionable information. It earns its place only by being non-empty.

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 schema is a bare empty object with no output schema and no annotations, so the description is the only source of meaning — and it fails to define what a group is or what listing returns. For a zero-parameter tool this is not complex, but the description still leaves the agent unable to predict behavior.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey. Baseline 4 applies per the rubric; nothing in the description misleads about inputs.

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 text 'The groups profiles are labelled with.' is a sentence fragment that never states a verb or what the tool actually does. One can infer it relates to listing groups used to label profiles, but the agent must reconstruct that from the name group.list plus guesswork, and it does not distinguish itself from siblings like group.create or group.delete.

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

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

There is no when-to-use guidance, no conditions, and no reference to alternatives such as group.create, group.delete, or profile.list. The agent is given no basis for choosing this 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 are provided, so the description carries the full behavioral burden. It usefully discloses that the address is never shown, which is a non-obvious privacy/behavior trait, but it omits side effects, navigation target, auth requirements, and whether external network access occurs.

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

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

Two short sentences with no wasted words. The action is front-loaded and the behavioral caveat follows immediately.

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

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

For a simple tool with no annotations, no output schema, and an empty input schema, the description states the core action and one important behavior. It still leaves gaps around prerequisites (how to obtain the message number), side effects, and routing versus related tools, so it is only minimally 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?

With 0 parameters, the baseline is 4 per the rubric. The description references a number even though the schema exposes no parameters, which creates some ambiguity, but there are no schema parameters for it to clarify or contradict.

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

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

It gives a specific verb (Open), resource (a link out of a message), and scoping detail (by its number), so the core action is clear. However, it does not distinguish this from siblings like open_page or navigate, and 'by its number' is slightly ambiguous about whether it refers to a message number or a link number.

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 no explicit when-to-use guidance, no when-not-to-use conditions, and no alternatives. It implies a message number is required but never says to call read_inbox first or how this differs from open_page.

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 disclosure burden. It does not say whether the gesture is a click, hover, or movement, whether it is reversible, whether it requires an active page/session, or why it must be 'outside the page map' — only that one gesture is dispatched.

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

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

A single front-loaded sentence with no filler. It is terse rather than padded, though the terseness comes at the cost of clarity.

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

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

With no annotations, no output schema, and an empty parameter object, the description is the only source of behavior — and it leaves the gesture type, coordinate source, and effect unspecified. Inadequate for an input-dispatch tool in a browser automation surface.

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 zero parameters, which normally earns a baseline 4, but the description explicitly requires 'a coordinate' that appears nowhere in the schema. That mismatch creates ambiguity rather than adding meaning, so it lands below baseline.

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

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

The verb 'Dispatch' and object 'gesture' are present, but 'humanized gesture' is undefined jargon and 'outside the page map' is opaque — an agent cannot tell whether this moves the pointer, clicks, or types. It is distinguishable from siblings only by name, not by stated effect.

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 indication of when to prefer this over click, press_and_hold, interact, or other input siblings, and no prerequisites or conditions given. The phrase 'outside the page map' hints at a niche, but the trigger is never 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses the capability set but says nothing about side effects, permissions, synchronization, failure behavior, or what state changes result from uploading a file or dragging.

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 terse and structured only as a comma-separated list, but it does not waste 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 browser-interaction tool with many sibling tools and no annotations or output schema, the description is too thin. It does not explain how to target an element, how the tool relates to click/type_text/fill_form, or what happens on success or failure.

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

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

The tool has zero parameters and the schema is empty, so there are no parameter semantics to document. Per the baseline for zero-parameter tools, the description is not expected to add parameter guidance.

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 specific interactions (hover, drag, upload, native dropdown) rather than restating the generic name, so an agent can infer the tool's scope. However, it does not explicitly differentiate itself from sibling tools like click, press_and_hold, or type_text, which also perform page interactions.

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?

Listing the supported operations implies that the tool should be used when one of those interactions is needed, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as click or fill_form.

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 and no output schema, the description carries the full behavioral burden and mostly doesn't. It conveys only that the result may be empty ('if anything'); it says nothing about whether the call blocks, whether it returns a single pending prompt or a queue, or whether identifiers returned are needed by interruption_respond.

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 no waste and the scope qualifier front-loaded. It is terse to the point of being fragmentary, but nothing in it is 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 zero-parameter tool with no annotations and no output schema, the description should at least sketch the return shape (a pending prompt object, an ID usable with interruption_respond, or an empty/absent result). Instead it covers only the existence question, leaving the agent unable to anticipate what it will receive or how to chain into interruption_respond.

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

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

The tool takes zero parameters, so the schema is trivially complete and the baseline of 4 applies. There is no parameter syntax or semantics the description could usefully add.

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

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

The description identifies a specific resource and scope: the browser's currently pending prompt, qualified by 'if anything' so the agent knows an empty result is possible. The verb is only implied by the tool name rather than stated, and no sibling (e.g. interruption_respond) is named or contrasted, 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 statement of when to call this versus alternatives. The obvious pairing with interruption_respond (check first, then respond) is never made explicit, and no prerequisite or boundary condition is given.

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, and it says almost nothing: it never states whether the answer accepts or denies the prompt, whether the action is security-sensitive or reversible, or what the outcome is. For a tool that resolves permission/device prompts, that silence is a real gap.

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

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

A single front-loaded sentence with essentially no filler, and the key identifying examples arrive first. It is lean to the point of thin, but nothing in it is wasted.

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 no parameters, the description is the only place to explain how this tool finds the pending interruption, what answering actually does, and what comes back — and it covers none of that. The interruption_list sibling strongly implies a required sequence the description never establishes.

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 zero parameters with full schema description coverage, so per the stated baseline there is no parameter surface for the description to compensate for. It adds only loose framing about what is being answered, which is consistent with a no-arg tool.

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?

Clear verb ("Answer") plus a specific resource ("what the browser itself is asking: a permission prompt, a device chooser"), with concrete examples that make the scope unambiguous. It doesn't name or contrast itself with the obvious sibling interruption_list, 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?

The description implies the triggering context (the browser is asking) but gives no explicit when-to-use guidance, no prerequisites, and never mentions interruption_list as the way to discover what needs answering. An agent is left to infer the pairing itself.

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 discloses that one handle is returned per profile, but does not state side effects, authentication needs, rate limits, whether handles must be released, or what 'the same' operation actually entails.

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

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

It is a single short sentence, but it is under-specified rather than concise. The phrase 'The same' is not front-loaded or self-contained, forcing the agent to resolve meaning from sibling context.

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

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

With no annotations, no output schema, and no parameters, the description must carry nearly all context. It only hints at batch leasing and one handle per profile; it omits how profiles are selected, what a handle is used for, and whether any cleanup is required.

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

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

There are zero parameters, so there is no schema parameter information for the description to supplement. The baseline for zero-parameter tools is 4, and the description does not mislead about parameter usage.

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 vague indication of batch operation ('for several profiles at once') and output shape ('one handle each'), but the verb is missing and 'The same' is anaphoric, requiring the agent to infer it refers to lease_profile. It does not clearly state what resource is being leased or distinguish itself explicitly from siblings.

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

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

It implies use when operating on several profiles at once, but gives no explicit when-to-use guidance, no when-not-to-use conditions, and no named alternative such as lease_profile. The agent must infer that this is the batch version of a single-profile lease.

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

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

No annotations exist, so the description carries the full burden, and it does disclose the side-effect chain: it reserves a resource, launches a browser, and binds a tab — useful disclosure that this is a mutating, stateful operation. It stops short of stating required permissions, failure/retry behavior, or that the lease must later be returned via release_profile.

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 sentence, four clauses, zero filler, with the primary action front-loaded. Nothing could be removed without losing a step in the operation.

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

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

For a zero-parameter tool it covers the operation's steps and its return value, which is reasonable. But with no annotations and no output schema, it omits the lease lifecycle (pairing with release_profile), error conditions when no free profile exists, and any timing/rate considerations.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline is 4. The description correctly notes the only meaningful output, 'the handle', rather than inventing 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?

Names a specific multi-step operation on a specific resource: reserve a profile, start its browser, bind a tab, return the handle. An agent understands the composite effect immediately. However, it does not differentiate itself from close siblings like lease_fleet, lease_renew, or profile.start, leaving ambiguity about which of these to pick.

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

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

There is no when-to-use or when-not-to-use guidance. With siblings such as lease_fleet, lease_renew, release_profile, and profile.start all touching the same lifecycle, the description never states which conditions select this tool over those 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 behavioral burden. It does disclose one useful trait - renewal preserves the existing handle rather than issuing a new one - but says nothing about expiry behaviour, error conditions if the deadline already lapsed, or whether any session/auth context 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?

A single short sentence with the effect front-loaded and no filler. It is efficient, though the 'handle' jargon costs a little clarity.

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

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

For a simple, parameterless tool with no output schema, a one-liner is close to sufficient, but with no annotations the description should at least clarify what lease is being operated on and what renewal returns or invalidates. It is minimally adequate rather than complete.

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

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

The tool takes zero parameters, so there is no parameter meaning for the description to add; the baseline for a 0-param tool applies. The one relevant implicit detail (which lease is renewed) is left unanswered, but no schema semantics are missing.

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 an action (extending a deadline) on a resource it calls a 'reservation', but the tool is named lease_renew and the term 'handle' is never defined. An agent can roughly infer the effect, yet the lease/reservation/handle terminology shift leaves the actual target somewhat vague and it names no sibling (e.g. lease_profile, lease_fleet) to disambiguate.

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

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

There is no when-to-use guidance, no conditions, and no mention of alternatives such as lease_profile or lease_fleet. The agent must guess the calling context entirely from the name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it says nothing about read-only status, side effects, return format, or requirements. It only describes the subject matter, not the tool's 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?

The single sentence is concise and contains no filler, but it is a sentence fragment rather than a front-loaded tool description. It is appropriately sized for a no-param tool, yet could be clearer.

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?

No output schema, annotations, or parameters exist, so the description must fully explain purpose and results. It leaves the agent unsure what 'measure_frames' actually returns or how it relates to sibling measurement tools, making it incomplete.

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

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

There are zero parameters, so the baseline is 4 per the rubric. The description adds no parameter semantics, but none are needed.

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

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

The description is a noun phrase describing a phenomenon ('How a moving element behaves over time') rather than stating a measurement action. It hints at slider/animation context but never says the tool measures or returns frames, so the agent must infer the verb from the name.

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 only a context ('for a slider or an animation') and no explicit when-to-use guidance or alternatives. Sibling tools like measure_gap and measure_rotation are not mentioned, so the agent gets no routing help.

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, and it discloses almost nothing. It implies a read-only measurement but does not state the units, the coordinate space, whether the result is a single scalar or a pair of offsets, or whether any page/element state must exist first.

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 sentence, front-loaded and free of padding, but it is a fragment rather than a sentence and is under-specified rather than genuinely concise. Nothing is wasted, but too little is said.

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 no parameters, the description is the only source of information, and it omits the return type entirely. For a measurement tool whose whole value is the number it produces, this is a significant 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?

The input schema is an empty object with zero parameters, which is the baseline-4 case per the rubric. The description does describe the conceptual operands ('a puzzle piece and its slot'), adding a little meaning, though the tool takes no arguments at all.

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 thing being computed ('the distance between two elements') and hints at the domain ('puzzle piece and its slot'), which is more than the bare name gives. But it is a noun phrase with no verb and no scope qualifier, and it never says how it differs from its close siblings measure_frames and measure_rotation.

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

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

There is no statement of when to call this tool, no prerequisites, and no mention of alternatives. The sibling set contains two other measurement tools, and the description provides nothing to help an agent choose between them.

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 of behavioral disclosure. It only indicates a measurement operation and does not describe permissions, side effects, input source, rate limits, or return format, leaving most behavioral traits undocumented.

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 short sentence with no filler, making it appropriately concise. However, its terse fragment style lacks structure for usage or return-value context, keeping it just below a fully polished definition.

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 no parameters, the description is the only source of context for the agent. It does not explain what input image is measured, how the measurement is obtained, or what the result looks like, so it is materially incomplete for correct 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?

The tool has zero parameters and an empty input schema, so there are no parameter semantics to explain. The baseline for a zero-parameter tool is 4, and the description has no parameter-related obligations to meet.

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 metric ('how far an image is turned') and a use case ('for a rotation challenge'), but it is a noun phrase rather than a clear verb+resource statement and largely restates the tool name. It does not clarify what the tool returns, how the image is identified, or how it differs from sibling measurement tools like measure_frames or measure_gap.

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

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

The phrase 'for a rotation challenge' implies a specific usage context, but there is no explicit guidance on when to use this tool versus alternatives, nor any when-not conditions. An agent can infer the general scenario but must still guess the exact trigger.

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 does not state whether the tool reads or mutates state, whether it requires permissions, what happens to existing tabs or history, or what the result contains. The brief phrase about a popup is not enough to infer safe invocation 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?

The description is short, but its brevity reflects under-specification rather than efficient conciseness. It is a single fragment-like sentence with no clear front-loaded action, so it does not earn its place as a useful tool definition.

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 browser-automation tool surrounded by many navigation and inspection siblings, this definition is incomplete. With no annotations, no output schema, and no parameter details, it should explain the tool's purpose, usage context, and behavioral scope, but it does not.

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 defines zero parameters, so there are no parameter semantics to document. The baseline for a zero-parameter tool is 4; the description neither helps nor harms here because there is nothing parameter-specific to clarify.

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 two resources, 'History and tabs' and 'popup a click just opened,' but never states a clear action verb. The tool name 'navigate' implies movement or selection, yet the description does not say what it navigates, what it returns, or how it differs from siblings like open_page or click.

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 about when to use this tool versus alternatives. Siblings such as open_page, click, snapshot, and interact exist in the same browser-automation context, and the description provides no conditions or exclusions to route the agent correctly.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read-only fetch and mentions a 'full page map' return, but says nothing about auth requirements, side effects, timeouts, or whether the fetch is headless or interactive. The 'public' qualifier hints at a restriction but is not explained.

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 tight sentence with no filler, and the action is front-loaded before the return value. Nothing wasted, though there is very little content overall.

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

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

For a zero-parameter tool with no output schema, the description should clarify how the address is provided and what a 'page map' contains. Neither is addressed, leaving critical invocation details 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?

The schema has 0 parameters, which normally sets a baseline of 4. However, the description says 'Navigate to a public http or https address', implying a target URL input that does not exist in the empty schema, so the agent is left unclear on how the address is supplied.

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 (navigate) plus resource (page) and adds the return behavior ('full page map'), which distinguishes it somewhat from the sibling 'navigate'. However, it never explains how it differs from 'navigate' or 'click', so an agent must infer the distinction.

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

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

There is no when-to-use or when-not-to-use guidance, and no mention of the obvious alternatives in the sibling list ('navigate', 'download_file', 'page_report'). The description only says what it does, not when to reach for it.

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 what is included and explicitly excluded (no headers, cookies, bodies), which is meaningful. However, it omits whether the tool requires an open page, whether it is read-only, and any other operational context.

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

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

Two short sentences with no wasted words. The content is front-loaded with the positive scope, followed by the exclusions. Appropriately sized for a no-parameter 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 lack of output schema and annotations, the description does provide the return contents and exclusions. However, it remains vague on what a 'request summary' includes and does not state the tool's dependency on an open page or session, leaving some context incomplete.

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. There is no parameter information to add, and the description does not need to compensate for schema gaps.

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

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

The description names the content (console messages and a request summary) but lacks a clear verb like 'get' or 'retrieve', and does not distinguish itself from siblings such as snapshot or read_text. It is more specific than a tautology but still vague about what the tool actually 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?

No guidance on when to use this tool versus alternatives. The only constraint given is what it never returns (headers, cookies, bodies), which is a scoping statement, not usage advice. An agent is left to infer context.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing: it does not state that the operation is read-only, what the return shape is (list of passkeys/sites), or any scope constraints. It only defines the concept of a passkey, not the tool's 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?

One short, front-loaded sentence with no filler. It is efficient, though its terseness is partly a symptom of under-specification rather than ideal compression.

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 trivial zero-parameter list tool with no output schema, a minimal description is tolerable, but it still omits the fact that the result is a collection and that the call is a safe read. A single added clause naming the returned passkeys would make it complete.

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

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

The tool takes zero parameters, so the baseline for this dimension is 4. There is nothing for the description to disambiguate beyond the (absent) 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 conveys the resource (site logins without a password, i.e. passkeys) but is a noun-phrase fragment that never states the action 'list'. It also does not distinguish this tool from the sibling passkey_retire, so an agent must infer that this is the read side of that pair.

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

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

There is no statement of when to call this versus alternatives such as passkey_retire, credential.list, or secret_list. The agent gets context about what passkeys are but no routing guidance for selecting this 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 exist, so the description carries the full burden. It does disclose one important trait — the removal is permanent ('for good') — which tells the agent this is destructive and irreversible. However, it omits any auth/permission requirements, confirmation semantics, or what happens if no passkey exists, leaving substantial behavioral 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?

A single short sentence with no filler, and the irreversible nature ('for good') is front-loaded as the key qualifier. Nothing is wasted.

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

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

For a zero-parameter, no-output-schema mutation tool, the description is too thin: it never explains how the target passkey/profile is identified or what confirmation/authorization the caller needs. It covers the intent and permanence but leaves the mechanics of invocation unaddressed.

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 zero parameters, so there is nothing for the description to disambiguate; per the rubric this is the baseline 4. No parameter meaning is added or needed.

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

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

States a specific verb+resource: retiring a passkey so a profile no longer offers it, distinguishing it from passkey_list (read) by its mutating intent. The main weakness is that it never explains which passkey is targeted, and with zero input parameters it's unclear how the caller scopes the operation.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of passkey_list as the read counterpart. An agent must infer that this is the removal counterpart to listing, and nothing states prerequisites or required session context.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the core effect (bulk creation of N independently-identified profiles), but says nothing about permissions, whether the operation is idempotent or reversible, resource limits, or the fate of existing profiles.

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

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

A single front-loaded sentence with no filler; the colon structure puts the mechanism before the payload details. It is only slightly cryptic in the 'N profiles' shorthand.

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?

This is a non-trivial bulk-provisioning operation with no output schema, no annotations, no parameters, and no explanation of the template source or the resulting fleet's shape. An agent cannot tell what it gets back or what to do next after calling it.

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

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

The input schema exposes zero parameters, which normally sets a baseline of 4. However, the description explicitly references inputs ('N', 'a template') that the schema does not expose, creating a real mismatch that could send an agent hunting for arguments that do not exist.

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

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

States a specific verb (make/instantiate), resource (fleet), and mechanism (from a template), which lets an agent distinguish it from sibling preset.list and from the singular leasing tools. It stops short of naming the preset/template concept used in the tool name, and the 'N profiles' phrasing hints at inputs the schema does not contain.

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

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

There is no when-to-use guidance, no prerequisite (e.g. that a preset must first exist), and no comparison to alternatives such as lease_fleet, lease_profile, or profile.batch, all of which plausibly compete for the same intent. The agent must infer the routing decision entirely on its own.

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 of behavioral disclosure and delivers nothing: no read-only confirmation, no return shape, no pagination or scoping behavior. For a zero-annotation tool this is a complete gap.

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

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

The text is short but under-specified rather than concise: a four-word noun fragment that omits the action entirely. Brevity here reflects missing content, not disciplined editing.

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 a fragmentary description, an agent has no information about what this returns or when to prefer it. Nothing an agent needs to invoke it correctly is present.

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

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

The tool takes zero parameters, so the baseline is 4 — there is no parameter semantics for the description to clarify or obscure. Schema description coverage is 100% but vacuous given the empty object.

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 stored templates" names a resource but supplies no verb — it never says the tool lists/retrieves them. It is effectively a restatement of the name preset.list and gives no basis for distinguishing it from sibling preset.instantiate.

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 indication of when to call this versus preset.instantiate or any other sibling, no prerequisites, and no scope conditions. The description offers no usage guidance at all, though it is not actively misleading.

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 disclose behavioral traits. It only says the gesture is completed in one call and omits side effects, target focus, timing, auth needs, and error behavior.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately brief, though not maximally 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?

With no annotations, no output schema, and no parameters, the description should clarify the execution context for a UI gesture. It does not explain what receives the gesture or when it is appropriate, leaving an agent with insufficient context to call 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?

The tool has zero parameters and the empty input schema fully covers them, so the description need not explain parameter meaning. The baseline for zero parameters applies.

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

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

It names the action (press-and-hold gesture) and notes it is bundled into one call, which hints at a higher-level gesture than press_key or click. However, it does not say what is being pressed or held, or what context the gesture operates on, so the purpose remains vague.

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

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

No guidance is given on when to use this tool instead of siblings like click, press_key, or scroll. There are no prerequisites or exclusions mentioned, leaving the agent to guess its role among many UI-interaction 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?

No annotations, so the description carries the full behavioral burden. It hints that a key and modifier chords are involved, but says nothing about focus requirements, whether chords use "Ctrl+Shift+A" syntax, key-down/up handling, or effects on the page.

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

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

A single sentence fragment, but its brevity reflects under-specification rather than efficiency. There is nothing front-loaded because there is no actionable 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?

For an input action tool with no annotations, no output schema, no defined parameters, and a host of similar input siblings, this is far too thin for an agent to invoke correctly.

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

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

The schema is a bare object with zero properties while the description references "a key, including modifier chords" – implying an input the schema does not define. With 0 params declared, the description must specify the argument shape, and it wholly fails to (no key name format, no chord syntax).

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?

"A key, including modifier chords." is a fragment, not a statement of purpose. It never says it presses/sends a key or that it operates on the browser page. Against siblings like click, type_text, and press_and_hold, an agent gets no clear differentiation.

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

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

No when-to-use, no conditions, no alternatives. Nothing routes the agent to press_key over press_and_hold, type_text, or click.

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 at all, the description carries the full behavioral burden and mostly drops it. It discloses that the operation is multiplexed over many profiles, which is useful, but says nothing about the irreversibility of 'delete', partial-failure/atomicity behavior when some profiles fail, permission requirements, or rate limits — all critical for a bulk mutation 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?

A single sentence, front-loaded with the action verbs and closed by the scope modifier. Nothing is redundant and nothing is padded; every word does work.

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 high-blast-radius bulk mutation tool with no annotations, no output schema, and an empty input schema, the description is far too thin. It omits failure semantics, delete irreversibility, and the mechanism for specifying target profiles, leaving the agent unable to invoke the tool correctly from the definition alone.

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 declares zero parameters, so the baseline is 4. The description compensates somewhat by enumerating the valid operations (start, stop, delete, reassign) and targets (proxy, extensions), which is genuinely semantic content an empty schema lacks — but it gives no clue how individual profiles are addressed in a batch call.

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

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

Names four concrete operations (start, stop, delete, reassign) on a named resource (profiles), with the scope modifier 'across many profiles' that separates it from the sibling single-profile tools profile.start, profile.stop, and profile.update. It is clear what the tool does, though it never names those siblings directly, so differentiation is inferred rather than stated.

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

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

'Across many profiles' implies this is the bulk alternative to profile.start/profile.stop/profile.create, but the description never says so explicitly and gives no when-not condition or prerequisite. The context is strong enough for an agent to infer bulk-vs-single usage, but it is left to inference.

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

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

No annotations are provided, so the description carries the full burden. 'Fresh identity' is a useful hint that a new identity is minted rather than reused, but nothing is said about side effects, persistence, auth requirements, or cleanup for what is clearly a mutation 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?

A single efficient sentence with the action front-loaded and no wasted words. It is arguably too terse for a creation tool, but as pure structure it is clean.

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 creation tool with no annotations and no output schema, the description should explain what a caller receives back (a profile handle, credentials, an id) so the profile can later be passed to profile.start or lease_profile. It omits return values and lifecycle context, leaving a meaningful gap.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. Schema coverage is trivially 100% and there are no parameters the description needs to compensate for.

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 (create) and resource (profile) and adds a scope qualifier ('with a fresh identity') that hints at a new, non-reused identity. It is distinguishable from siblings like profile.start, profile.stop, and profile.update, though it never names them 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?

There is no statement of when to use this versus alternatives such as lease_profile, profile.batch, or preset.instantiate, nor any prerequisites or context for choosing it. The agent must infer usage entirely from the name.

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

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

With no annotations at all, the description carries the full burden. It reveals that a state field is included in the result, but says nothing about whether stopped/inactive profiles are listed, ordering, pagination, or any auth requirement.

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 tight sentence with no filler and the key information (resource + scope + returned state) front-loaded. It is terse rather than padded, though it is arguably under-specified for a fragment without a verb.

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

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

A parameterless read-only list tool is simple enough that this nearly suffices, but with no output schema the description should say more about the shape of the returned list and whether the result is filtered or paged.

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

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

The tool takes zero parameters, so there is no parameter semantics to document. Baseline 4 applies.

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

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

Identifies the resource (profiles), the scope (on this daemon), and what is returned (their state). The verb is only implied by the tool name, but the resource is specific enough to distinguish it from siblings like profile.create, profile.start, profile.stop, and profile.update.

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

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

There is no when-to-use guidance and no mention of alternatives. The many profile.* siblings (create/start/stop/update/batch) make a routing sentence genuinely useful, and none is provided.

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 does disclose one genuinely non-obvious behavior — the started browser is not agent-drivable — but says nothing about lifecycle, persistence, cost, or whether a lease/session is required first.

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 immediately followed by the constraint. No filler; each sentence carries distinct information.

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

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

With no output schema and no annotations, the description is the only source of behavioral information. It flags the key gotcha but omits what the call returns, what state it leaves behind, and which sibling tool to use for a drivable session.

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

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

The tool takes zero parameters, so the baseline is 4. There is no parameter surface for the description to clarify, and it introduces none of its own.

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

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

States a specific verb and resource ('Start a profile's browser'), which is clearly distinguishable from profile.create, profile.stop and profile.list. The caveat in the second sentence also implicitly separates it from session/driving tools, though it never names 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 line 'Does not give you one you can drive' implies this is not the tool to call when you need an interactive session, but no alternative (e.g. lease_profile, open_page) is named and no conditions for choosing this tool are given. 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?

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the stop is graceful or forced, whether it is idempotent, what happens to open pages/sessions, or whether an active lease is affected.

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, front-loaded sentence with no filler. It is efficient, though so terse that it omits any detail an agent might need for safe invocation.

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 lifecycle mutation with no annotations and no output schema, the description should say more about effects (termination semantics, lease/release interaction with release_profile). As written it is too thin to fully orient an agent.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify; baseline is 4. The description correctly implies the target is identified by session/context rather than an argument.

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 (stop) and resource (profile's browser), so an agent knows exactly what action occurs. It is clearly the inverse of sibling profile.start, though the description never names that relationship 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 call this versus adjacent lifecycle tools like release_profile, lease_profile, or profile.update. The agent must infer the distinction between stopping a browser and releasing a leased profile on its own.

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 identifies the tool as a mutation ('Change'), but does not disclose side effects, reversibility, permission requirements, or what happens to settings that are not mentioned. This is a significant gap for a mutation 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 with no filler. It is appropriately sized for the tool, though it is so terse that it omits useful context rather than containing 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?

Given a mutation tool with no annotations, an empty input schema, and no output schema, the description is not complete enough. It lists editable fields but omits behavioral details such as permissions, side effects, and how the update is applied.

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 is an empty object and the parameter count is 0, so the baseline is 4. The description adds useful semantic content by listing the properties that can be changed (name, proxy, group, geo mode), though it does not explain how those changes are supplied or formatted.

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 ('Change') and resource ('a profile's settings'), and it names the editable fields (name, proxy, group, geo mode). It is clearly distinct from profile.create, profile.list, profile.start, and profile.stop, though it does not explicitly call out those alternatives.

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 profile.create, profile.batch, or profile.start/stop. It also omits prerequisites such as required permissions or conditions under which a profile can be updated.

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, and it discloses nothing about what is returned, whether the pool is global or session-scoped, or what permissions are needed. "Never credentials" is a caution, not a behavioral disclosure.

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 terse fragments are economical but under-specified rather than concise; brevity here removes the information an agent needs, and the fragments are not a coherent sentence.

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

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

With no output schema and no annotations, the description is the only source of information, and it omits return contents, scope, and pagination behavior for a list tool. It is inadequate for an agent to invoke the tool with confidence.

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 declares zero parameters, so per the calibration baseline a 4 applies; there is nothing for the description to disambiguate. No parameter claims are made or contradicted.

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 proxy pool. Never credentials." is a noun fragment that restates the tool name rather than stating a verb+resource action; it never says it lists or returns proxies. The only value-add is negative framing, which does not convey 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?

There is no when-to-use guidance and no named alternative among the many siblings (credential.list, profile.list, session.export, etc.). "Never credentials" is an implicit boundary against credential tools, but no positive selection condition is given.

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 implies a read-only retrieval of confirmation codes but does not disclose authentication needs, whether messages are marked read, return format, or rate limits. Only a hint of content channels is added.

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 short fragment with no wasted words, but it is structurally a noun phrase rather than a clear statement, which reduces clarity. It is concise but under-specified.

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

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

With no parameters, no output schema, and no annotations, the description should explain what the tool returns and when to use it. It only hints at content (confirmation codes via mail or text) and omits return format, scope, and usage 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?

Zero parameters and 100% schema description coverage give a baseline of 4. The description adds no parameter information because there are none; the schema fully defines the empty 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?

The description names the resource (confirmation codes) and delivery channels (mail or text), which hints at content, but it omits a clear verb and does not say whether it lists, reads, or fetches. Sibling `inbox_open_link` suggests an inbox family, yet no differentiation is provided. Vague purpose.

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 when-to-use, prerequisites, or alternatives are given. The agent must infer that this is the tool for retrieving confirmation codes, with no stated conditions 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?

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only extraction of text ('verbatim'), but does not describe execution prerequisites, return format, waiting behavior, or limitations, leaving significant gaps for a browser-automation 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?

A single, front-loaded sentence with no filler. It states the action, the target, and the intended context immediately.

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

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

Given a simple 0-param tool, the description is minimally adequate. But with no annotations and no output schema, it should at least hint at the return format or execution behavior, which it does not.

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

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

The tool has zero parameters and the schema is effectively empty, so there is nothing for the description to clarify. Baseline for a 0-param tool is 4.

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 ('Read') and resource ('page's prose verbatim'), plus a usage scope ('article or thread of comments'). This distinguishes it from value-oriented siblings like read_value or visual tools like screenshot, but it does not name those alternatives explicitly.

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

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

The phrase 'for an article or a thread of comments' gives a clear usage scenario. However, it provides no guidance on when not to use the tool and does not mention alternatives such as read_value or snapshot, leaving sibling selection partly to inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Read', but does not explain how to specify an element (schema has no parameters), whether the operation is safe/idempotent, what is returned, or any side effects. This is essentially a label with no behavioral context.

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 that is as short as possible. Every word contributes to stating the purpose.

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

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

Given no parameters, no output schema, and no annotations, the description should explain how the tool works and what it returns. Instead, it leaves critical gaps: it doesn't say how to reference the element or select the one thing to read, making it difficult for an agent to invoke correctly.

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

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

There are 0 parameters, so there are no parameter semantics to evaluate. Per the rubric, a tool with no parameters receives a baseline score of 4.

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 (Read) and resource (one thing from an element) and enumerates the possible targets (text, attribute, count, table). It is clear enough to distinguish from a generic tool, but does not explicitly differentiate from sibling tools like read_text or snapshot.

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

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

No guidance is given about when to use this tool versus alternatives. It does not mention read_text, snapshot, or any other sibling, nor does it state prerequisites 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 behavioral burden, yet it discloses almost nothing: not what is captured (video, trace, HAR), where the recording is stored, how long it persists, or how to retrieve it. The toggle semantics of a single start/stop tool are never explained, which is a significant gap for a stateful 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 sentence with no filler, and the core action is front-loaded. The brevity is appropriate in structure, though it is under-specification rather than genuine efficiency; still, nothing in the text is wasted.

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

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

For a zero-parameter, stateful recording tool with no output schema, the description leaves critical questions unanswered: what triggers start vs. stop, what artifact is produced, and where it goes. With no annotations and no output schema to lean on, the description is not complete enough for confident 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?

The tool takes zero parameters, so per the rubric the baseline is 4. The empty schema means there is no parameter semantics to convey, and the description does not need to compensate for anything in this dimension.

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 verb pair and a resource ("start or stop recording what the browser is doing"), so the basic intent is graspable. However, it is a single tool performing two opposite operations with no parameter to disambiguate, and it does not differentiate itself from the sibling 'video' tool, which plausibly also records. That ambiguity keeps it from being a clear, distinguishable purpose.

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 invoke this versus alternatives such as 'video', 'screenshot', or 'measure_frames'. Nothing explains the condition that starts versus stops the recording, so an agent cannot tell which call state it is in or when recording is appropriate.

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

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

With no annotations, the description carries the full burden, and it does disclose real side effects: the reservation ends and the browser is stopped, plus a record of the session is written. It says nothing about reversibility, what happens if no lease is held, whether the profile data survives, or permission requirements, which are the questions that matter for a terminal teardown call.

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

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

Two short sentences, zero filler, with the primary effect front-loaded and the side-effect (recording) trailing. Nothing is padded and nothing needs reordering.

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 parameterless lifecycle terminator with no annotations and no output schema, the description covers the core contract but omits the state requirements an agent needs: whether a lease must be active, what error surfaces if there is nothing to release, and how this differs from the other stop/lease siblings. Adequate but with a clear 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?

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline for a parameterless tool applies. The description correctly implies the tool is targetless, operating on the caller's current reservation.

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 effect: 'End the reservation and stop the browser.' That is more than a restatement of the name and tells the agent this is the teardown step of a profile lifecycle. It does not, however, distinguish itself from nearby siblings such as profile.stop, profile.update or lease_renew, so an agent still has to guess which teardown tool applies.

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

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

There is no when-to-use guidance, no prerequisite stated (e.g. that a lease must be held), and no mention of alternatives like lease_renew for extending work or profile.stop for a different kind of shutdown. The agent gets the what but not the when.

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 disclosure burden, yet it says nothing about ordering, pagination, result limits, or whether this is read-only. The only behavioral content is the data source, which is minimal for a list tool with zero structured support.

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

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

It is short, but half the sentence is rationale ('so an agent can see what was already tried') rather than operational information, and the missing verb makes it read as an incomplete clause. Under-specification rather than tight conciseness.

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

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

The tool is simple (no params, plain object schema), so a short description can be adequate, but with no output schema the description should at least gesture at what a run record contains or how results are ordered. The unresolved 'this profile' reference also leaves selection semantics unclear.

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 takes no parameters, so per the baseline there is nothing for the description to compensate for. The phrase 'this profile's' implies an implicit ambient profile context rather than a parameter, which is mildly ambiguous but does not introduce an undocumented argument.

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

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

The description identifies the resource and its scope ('this profile's earlier runs'), so an agent can infer a listing operation, but there is no explicit verb and the fragment reads as a clause rather than a definition. It also doesn't distinguish itself from similarly named siblings such as start_run or passkey_list.

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 trailing rationale ('so an agent can see what was already tried') hints at a use case — checking prior attempts to avoid duplication — but there is no explicit when-to-use, when-not-to-use, or named alternative. No guidance on whether this supersedes or complements start_run or other list tools.

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

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

With no annotations, the description carries the full behavioral burden and mostly fails it. It does disclose that the output is a PDF artifact, but says nothing about preconditions (an open page), whether the save is synchronous, permissions, or where the artifact lands/how to retrieve it.

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

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

A single efficient sentence with the action front-loaded and zero padding. It is arguably under-specified rather than over-verbose, but as a matter of structure it is tight.

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

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

For a zero-parameter tool with no output schema, the description gives the essential outcome (a PDF artifact) but omits how the artifact is identified or retrieved, despite a sibling artifact_list existing. An agent knows what it does but not much about the surrounding workflow.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies no arguments are needed.

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

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

States a specific verb (save) and resource (current page → PDF artifact), which is enough to separate it from siblings like screenshot, record, and download_file. It does not explicitly name those alternatives, 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?

No when-to-use guidance, no exclusions, and no named alternative. The only implied condition is that a page must currently be open, which the agent must infer from 'current page'. Nothing tells the agent when to pick this over screenshot or download_file.

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 full behavioral burden. It says what action occurs but not what the agent gets back (image data? saved file?), whether it requires permissions, or any side effects. This is a significant gap 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?

A single, front-loaded sentence with zero waste. It states the action and the condition in one concise clause.

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 annotations and no output schema, the description should explain what the agent receives (e.g., image data, file path) and how to specify an element if applicable. It omits these details, leaving the invocation and return behavior unclear.

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

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

There are no input parameters, so there is nothing for the description to document beyond the baseline. The phrase 'or one element' hints at a targeting option not exposed in the schema, but this is a minor misalignment rather than a parameter semantics failure.

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 'Capture' and resource 'the page or one element', and hints at a condition ('when the text map cannot describe it'). It distinguishes itself from text-oriented siblings but does not name any alternative 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?

Provides a usage condition ('for when the text map cannot describe it'), which implies when to choose this over text-map tools. However, it does not name alternatives or state when not to use it, leaving the agent to infer the trade-off.

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 does disclose one genuine behavioral trait: it is a real wheel gesture with momentum rather than an instant jump. That is meaningful for automation timing. It stops short of stating what gets scrolled, direction, amount, or any permission/session requirements.

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

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

A single short sentence with no filler, and the distinguishing trait (momentum vs jump) is front-loaded. It is arguably under-specified rather than over-long, which is not a conciseness failure.

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 zero-parameter tool with no output schema, the description is minimally adequate but leaves open what is being scrolled (page vs. element) and how far. In a browser-automation sibling set, that ambiguity is worth resolving, though the tool's simplicity limits the damage.

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

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

The tool takes zero parameters, so the baseline of 4 applies. There is nothing for the description to clarify or compensate for, and the schema (empty object) is sufficient.

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 name 'scroll' plus the phrase 'a real wheel gesture with momentum' conveys the action and its manner, so an agent can infer the purpose. However there is no explicit verb+resource statement (e.g. 'scrolls the page viewport') and no differentiation from siblings like navigate, open_page, or interact, which all move within a page context.

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 when-to-use guidance, no conditions, and no alternatives. It never says to use this instead of, say, navigate or interact, nor when a momentum scroll is preferable. Usage is entirely left to inference.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: secrets are usable but not readable. However, it does not describe return format, pagination, authentication requirements, or other behavioral 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?

The description is a single, short sentence with no wasted words. It is front-loaded with the resource, though it reads as a noun phrase rather than an action statement.

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

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

For a zero-parameter list tool with no output schema and no annotations, the description gives the essential security property but leaves the return shape unclear. It does not clarify whether it returns secret names, identifiers, or metadata, which is a meaningful gap when no output schema exists.

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

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

The tool takes zero parameters, so there are no parameter semantics to document. The schema is empty and coverage is not applicable, making the baseline of 4 appropriate.

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

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

The description indicates the tool relates to secret values a profile holds that the agent can use but not read, which is specific to secrets but does not use a clear verb like 'list' and does not distinguish from siblings such as credential.list or passkey_list. It is a vague purpose rather than a tautology.

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

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

There is no explicit guidance on when to use this tool versus alternatives like credential.list or passkey_list. The phrase 'may use but not read' hints at a use case but does not state when or why an agent should prefer this 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 are provided, so the description carries the full burden of behavioral disclosure. It does add that the output is a 'password-encrypted bundle', which is useful, but it says nothing about read-only vs. mutating behavior, required permissions, how the password is supplied, or 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 short phrase, so it is concise and front-loaded, but it is under-specified rather than optimally structured. It reads as a fragment rather than a purposeful definition.

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 and no output schema, the description must explain enough for an agent to invoke the tool correctly. It does not clarify how the profile is identified, where the encrypted bundle is delivered, or what the caller should expect. Given the tool's export purpose, this is a significant 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?

The tool has zero parameters, so the baseline for parameter semantics is 4. There is no parameter information for the description to add or omit.

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

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

The description is a noun phrase that restates the tool name's resource ('session') and adds an output format detail ('password-encrypted bundle'), but it never states the action with a verb. It does not distinguish the tool from its sibling session.import. This is closer to a tautology than a clear purpose statement.

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, when not to use it, or which alternative (e.g., session.import) is appropriate. The description gives no context about prerequisites or intended 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?

No annotations are provided, so the description carries the full behavioral burden, and it barely delivers. It implies a mutation ("into a profile") and some unsealing/decryption step, but says nothing about side effects, whether existing profile data is overwritten, permissions, or whether the operation is reversible.

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

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

It is a single short sentence, so it is not verbose, but the phrase "such a bundle" is empty without context and makes the sentence fail to communicate. This is under-specification masquerading as conciseness, similar to the calibration example that scored 2.

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 and no output schema, the description must fully explain the operation, but it omits what a bundle is, where it comes from, what happens to the existing profile, and what a caller should expect. For an import tool that writes into a profile, this is materially incomplete.

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 zero parameters, and the rules set a baseline of 4 for that case. There is no parameter meaning the description could add, so this dimension is appropriately neutral.

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

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

It gives a verb ("unseal") and a target ("a profile"), so the general import-into-profile action is inferable, especially next to the sibling session.export. But "such a bundle" is a dangling reference with no antecedent, and the description never states that this is a session bundle, leaving the resource only vaguely defined.

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 versus session.export, profile.update, or any other sibling. It does not mention prerequisites (e.g., needing a bundle produced by session.export) or when the tool should not be used.

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 does disclose one real trait: the default return is a diff rather than a full dump. However, it is cryptic about what is being diffed, when, and against what baseline, and it omits format, size, and safety context entirely.

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 around the core purpose, with no filler. The brevity is clean structurally, though it comes at the cost of the clarity issues above.

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 page-capture tool with no annotations and no output schema, the description should explain what a snapshot contains and how it differs from a screenshot or page report. It leaves the agent guessing about return format, diff semantics, and the nonexistent full-map option.

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 zero parameters and full coverage, which would normally be a baseline 4. But "unless you ask for a full map" implies an optional mode parameter that the empty schema does not provide, actively misleading the agent about how to request the full-map behavior it advertises.

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?

"What is on the page now" conveys that this captures current page state, but the verb is implicit and it does not distinguish itself from siblings like screenshot, page_report, or read_text, which also surface page content. An agent cannot tell from this text what kind of snapshot (DOM, text, image) is returned.

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 usage cue is "unless you ask for a full map," which gestures at a mode but names no condition, prerequisite, or sibling alternative. There is no explicit when-to-use guidance against the many other page-reading tools in the sibling list.

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 behavioral disclosure. It hints that the operator will see the sentence, which is one small behavioral detail, but says nothing about what starting a run entails (state changes, side effects, permissions, or aftermath).

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

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

It is a single compact sentence with no filler. However, it is front-loaded as a directive rather than as tool purpose, so its brevity does not make the definition more useful.

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

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

For a zero-parameter, annotation-free tool, the description should at minimum state what the tool does and when to call it. It gestures at declaring a work purpose but omits the action itself and any routing context, leaving the definition largely incomplete.

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 zero parameters, and the rubric sets the baseline at 4 for no-param tools. The description's implied 'one sentence' input has no corresponding schema field, but with no parameters to document, there is no schema compensation 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 never states what start_run does—no verb like 'starts' or resource like 'run' appears. Instead it gives an instruction ('Say in one sentence...') that reads like a UI prompt and even implies an input the empty schema does not accept, making the tool's actual action missing and misleading.

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 when-to-use guidance, no exclusions, and no mention of alternatives such as task.start or run_list. The agent is given no basis for choosing this tool over 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 of behavioral disclosure, yet it says nothing about side effects, permissions, whether the profile must be active, or what happens to the task afterward. For a mutation tool with zero annotation coverage, this is effectively no 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?

One short sentence with no filler, which is appropriate in size, but the brevity comes from vagueness rather than precision — the front-loaded content is a metaphor that does not identify the operation cleanly.

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 an empty parameter schema, the description is the only source of information and it does not explain what gets created, where it lands, or what the caller must provide. Far too little for a write operation in a task-management family.

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

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

The tool takes no parameters and schema coverage is 100%, so the baseline is high. However, the description implies inputs that the empty schema cannot supply ('a profile's list', and the now-vs-later choice), and it never explains how those are specified, leaving a real ambiguity.

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 restates the name in metaphor: 'put work on a profile's list' means adding a task, but the resource ('work') and container ('list') are never stated plainly, and it gives no differentiation from siblings like task.start, task.list, or task.done. An agent must guess that this creates a queued task rather than executing one.

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 versus task.start or task.list. The fragment 'for now or for later' faintly implies a scheduling choice but is too vague to route the agent, and no prerequisites or alternatives are named.

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 implies a destructive mutation ('Drop') but does not disclose whether cancellation is reversible, what state the task must be in, what permissions are required, or what side effects occur.

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 wasted words. Its brevity is structurally clean, though it borders on under-specification for a mutation tool.

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

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

For a zero-parameter task cancellation tool with no annotations and no output schema, the description omits critical context: which task is dropped, whether the call affects the current task or requires external context, and what happens on success or failure. It is too thin to be safely invoked without additional inference.

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 zero parameters, so there are no parameter semantics to explain and the baseline is 4. The description appropriately does not invent parameter details, though it also does not clarify how the target task is identified.

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 ('Drop') and resource ('task'), and 'no longer applies' implies cancellation/abandonment rather than completion. However, it does not explicitly distinguish this tool from siblings like task.done, which is the nearest alternative.

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

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

The phrase 'that no longer applies' gives an implied condition for use, but there is no explicit guidance on when to choose this over task.done, task.start, or other task lifecycle tools, and no exclusions or prerequisites are stated.

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

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

No annotations exist, so the description carries the full behavioral burden. It does not disclose whether the close is terminal or reversible, how it behaves on an already-completed task, or what side effects (notifications, run cleanup) occur. Only the bare implication of a state transition is present.

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 action verb front-loaded and no padding. It is efficient, though the closing clause is too vague to earn its place fully.

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

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

For a zero-parameter lifecycle tool with no annotations and no output schema, the description should at minimum state terminal semantics and the relationship to task.start/task.cancel. It omits both, leaving an agent unable to call it correctly in ambiguous cases.

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

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

With zero parameters, the baseline is 4, but the phrase "with what came of it" strongly implies an outcome argument that the empty input schema does not define. This leaves the agent unsure whether payload data is expected, so the description mildly conflicts with the schema rather than cleanly supplementing 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?

"Close a task" gives a recognizable verb and resource, but the trailing clause "with what came of it" is vague about whether an outcome is supplied or merely recorded. With siblings task.cancel, task.start, and task.add in the same family, the description never distinguishes done (successful completion) from cancel (abandonment), which is exactly the distinction an agent needs.

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 when-to-use guidance is present. The description does not say whether task.start must precede it, whether an in-progress task is required, or when task.cancel is the correct alternative over task.done.

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 of behavioral disclosure, and it delivers almost nothing beyond the word "outstanding." It does not state that this is a read-only operation, whether results are scoped to an active profile or session, how results are ordered or paginated, or what happens when a profile has no outstanding items.

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

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

The description is short but under-specified rather than concise: the single fragment is not front-loaded with a verb and omits the essential scope of the result. Brevity here reflects missing content, not efficient editing.

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

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

With no output schema and no annotations, the description is the only source of information about what the agent gets back, yet it says nothing about the return shape, item fields, or filters. For a list-style tool this leaves the agent unable to anticipate or act on the result.

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 zero parameters and zero required inputs at 100% coverage, so there is nothing for the description to disambiguate. Baseline 4 applies for a parameterless tool.

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 phrase "What is outstanding on a profile" is a fragment rather than a stated verb+resource; it never says the tool lists tasks or returns a list. An agent can partially infer intent from the sibling names (task.add, task.start, task.done, task.cancel), but the description itself does not distinguish this tool beyond a vague notion of pending items.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of alternatives such as run_list or profile.list, and no stated prerequisites (e.g., whether a profile must be started or a session active). The agent is left to guess the context entirely.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It indicates a mutation (marking a task as being worked on) but does not disclose permissions required, side effects, idempotency, or what happens if the task is already in progress. Significant behavioral gaps remain.

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 no wasted wording and is front-loaded. However, its brevity borders on under-specification for a state-changing tool, and it fails to structure any additional useful context.

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

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

Given the absence of annotations, output schema, and parameters, the description provides only minimal context. It is adequate to understand the basic action but does not clarify how the task is identified, what the effect looks like, or how it relates to sibling task-state tools. More detail would be expected for a mutation 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?

The tool has zero parameters, so there are no parameter semantics to describe. The baseline for zero-parameter tools is 4, and the empty input schema is consistent with the description.

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 a specific action: marking a task as being worked on. It effectively distinguishes the tool from related siblings like task.add or task.done by implying an in-progress state change. However, it does not explicitly differentiate itself from task.cancel or task.list beyond the state named.

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 no guidance on when to use this tool versus alternatives such as task.add, task.done, or task.cancel. It also omits any prerequisites or context for starting a task. Only the implied meaning of 'being worked on' suggests 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 behavioral burden, yet it discloses no permissions, session/state prerequisites, source of the audio, or whether the result is stored or returned. The only behavioral hint is that it consumes an 'audio challenge', which is never defined.

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

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

It is a single short sentence with no bloat, but the closing clause 'through the operator's own command' spends words without adding meaning, making the statement feel elliptical rather than concise.

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

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

For a zero-param tool with no output schema, the description should explain what the transcribed text contains and where it goes, especially given the odd phrase 'audio challenge'. Without annotations or an output schema, those gaps are not covered elsewhere.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate beyond what the empty schema already shows. Baseline of 4 applies for a no-parameter tool.

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

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

The verb+resource are inferable ('turn an audio challenge into text' = transcribe audio), but 'audio challenge' and especially 'through the operator's own command' are cryptic and leave the actual operation ambiguous. Nothing distinguishes it from siblings like read_text or read_value.

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 when-to-use, when-not-to-use, or alternative is given. The agent cannot tell from the description when transcription is the right call versus read_text, read_value, or other extraction 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 behavioral burden. It usefully discloses that typing follows 'this profile's own cadence' and that it clicks the field first, but it omits side effects, whether existing text is replaced, error handling, or permission requirements.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to stating the action and the profile-specific cadence, making it efficiently 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 no annotations, no output schema, and an empty input schema, the description must compensate heavily. It states what the tool does but lacks usage context versus siblings, side-effect details, and conditions for invocation, leaving an agent under-informed for selection and correct 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?

The tool takes zero parameters, so there are no parameter semantics to document. The empty schema is fully consistent with the baseline for parameter-free tools; the description has no additional parameter meaning to add.

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

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

The description names a specific verb and resource: 'Click a field and type into it'. It also adds a scope detail ('at this profile's own cadence'), but it does not differentiate this tool from siblings like fill_form or input.humanize, leaving the agent to infer when this specific tool is appropriate.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative guidance. The sentence implies a basic use case for typing into a field, but with many sibling tools such as fill_form and press_key, an agent receives no routing context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints that rendering is long-running and asynchronous, but never says whether the call blocks, how to poll, what identifies a given render, or what happens on completion or failure. For an async job tool this is a substantial gap.

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

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

A single compact sentence with no filler. It is front-loaded, though the compression comes partly at the cost of clarity rather than through efficient 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?

With no annotations, no output schema, and an empty input schema, the description is the only source of information, and it leaves the core mechanics of an asynchronous render workflow unexplained. An agent cannot reliably know how to invoke or poll it.

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

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

The schema declares zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter meaning is lost because none exist.

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

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

States two loosely-defined operations ('turn a recording into a film' and 'check on one that is rendering'), so the agent knows this tool starts renders and reports status. However, 'film' is imprecise, and with zero parameters there is no stated way to tell the two modes apart or to reference which render to check. It distinguishes itself from the sibling 'record' only by implication.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as 'record' or 'measure_frames'. The agent must infer that the same tool both initiates and polls a render, with no instruction on how to select either behavior.

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 entire behavioral burden. It names three wait modes but omits timeout behavior, what happens on timeout failure, whether it blocks or polls, and what the call yields despite there being no output schema to fall back on.

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 with the central concept ('Wait for') front-loaded and no filler. It is efficient, though its brevity is partly under-specification rather than disciplined concision.

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 automation primitive with no annotations, no output schema, and no parameters, the description should cover failure modes, timing semantics, and the return value. None of those are present, so an agent cannot predict what a successful or failed wait looks like.

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 zero parameters, which normally earns a baseline 4, but the description explicitly references inputs ('text', 'an element', page-quiet condition) that the empty object schema cannot accept. That mismatch leaves the agent unsure how to express the wait target, so it lands below the zero-param baseline.

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

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

States a specific verb ('wait for') and three distinct conditions it can await: text/element appearing, going away, or the page going quiet. That is concrete enough for an agent to know the tool's job, but it never distinguishes itself from workflow siblings like snapshot or page_report that could also be used to observe page state.

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 context (awaiting asynchronous UI changes) but gives no explicit when-to-use, when-not-to-use, or alternative. There is no guidance on whether to prefer this over snapshot, read_text, or measure_gap when confirming page state, all of which appear in the sibling list.

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